diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000..55583a6 Binary files /dev/null and b/.DS_Store differ diff --git a/.obsidian/app.json b/.obsidian/app.json new file mode 100644 index 0000000..b78fa8a --- /dev/null +++ b/.obsidian/app.json @@ -0,0 +1,8 @@ +{ + "newLinkFormat": "relative", + "attachmentFolderPath": "./assets", + "alwaysUpdateLinks": true, + "strictLineBreaks": true, + "useMarkdownLinks": true, + "promptDelete": false +} \ No newline at end of file diff --git a/.obsidian/appearance.json b/.obsidian/appearance.json new file mode 100644 index 0000000..267d9d7 --- /dev/null +++ b/.obsidian/appearance.json @@ -0,0 +1,5 @@ +{ + "theme": "moonstone", + "baseFontSize": 15, + "accentColor": "" +} \ No newline at end of file diff --git a/.obsidian/community-plugins.json b/.obsidian/community-plugins.json new file mode 100644 index 0000000..831c3e2 --- /dev/null +++ b/.obsidian/community-plugins.json @@ -0,0 +1,5 @@ +[ + "number-headings-obsidian", + "obsidian-git", + "obsidian-image-toolkit" +] \ No newline at end of file diff --git a/.obsidian/core-plugins-migration.json b/.obsidian/core-plugins-migration.json new file mode 100644 index 0000000..67cdbfd --- /dev/null +++ b/.obsidian/core-plugins-migration.json @@ -0,0 +1,30 @@ +{ + "file-explorer": true, + "global-search": true, + "switcher": true, + "graph": true, + "backlink": true, + "outgoing-link": true, + "tag-pane": true, + "page-preview": true, + "daily-notes": true, + "templates": true, + "note-composer": true, + "command-palette": true, + "slash-command": false, + "editor-status": true, + "starred": true, + "markdown-importer": false, + "zk-prefixer": false, + "random-note": false, + "outline": true, + "word-count": true, + "slides": false, + "audio-recorder": false, + "workspaces": false, + "file-recovery": true, + "publish": false, + "sync": false, + "canvas": true, + "bookmarks": true +} \ No newline at end of file diff --git a/.obsidian/core-plugins.json b/.obsidian/core-plugins.json new file mode 100644 index 0000000..9405bfd --- /dev/null +++ b/.obsidian/core-plugins.json @@ -0,0 +1,20 @@ +[ + "file-explorer", + "global-search", + "switcher", + "graph", + "backlink", + "canvas", + "outgoing-link", + "tag-pane", + "page-preview", + "daily-notes", + "templates", + "note-composer", + "command-palette", + "editor-status", + "bookmarks", + "outline", + "word-count", + "file-recovery" +] \ No newline at end of file diff --git a/.obsidian/graph.json b/.obsidian/graph.json new file mode 100644 index 0000000..c800335 --- /dev/null +++ b/.obsidian/graph.json @@ -0,0 +1,30 @@ +{ + "collapse-filter": true, + "search": "", + "showTags": false, + "showAttachments": false, + "hideUnresolved": false, + "showOrphans": true, + "collapse-color-groups": true, + "colorGroups": [ + { + "query": "", + "color": { + "a": 1, + "rgb": 14048348 + } + } + ], + "collapse-display": true, + "showArrow": true, + "textFadeMultiplier": 0, + "nodeSizeMultiplier": 1.24405110677083, + "lineSizeMultiplier": 2.08803304036458, + "collapse-forces": true, + "centerStrength": 0.397054036458333, + "repelStrength": 8.59700520833333, + "linkStrength": 1, + "linkDistance": 193, + "scale": 1.7643243860470785, + "close": false +} \ No newline at end of file diff --git a/.obsidian/hotkeys.json b/.obsidian/hotkeys.json new file mode 100644 index 0000000..9e26dfe --- /dev/null +++ b/.obsidian/hotkeys.json @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/.obsidian/plugins/number headings/data.json b/.obsidian/plugins/number headings/data.json new file mode 100644 index 0000000..ead3404 --- /dev/null +++ b/.obsidian/plugins/number headings/data.json @@ -0,0 +1,10 @@ +{ + "skipTopLevel": false, + "firstLevel": 1, + "maxLevel": 6, + "styleLevel1": "1", + "styleLevelOther": "1", + "auto": true, + "separator": "", + "contents": "" +} \ No newline at end of file diff --git a/.obsidian/plugins/number headings/main.js b/.obsidian/plugins/number headings/main.js new file mode 100644 index 0000000..9750085 --- /dev/null +++ b/.obsidian/plugins/number headings/main.js @@ -0,0 +1,882 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ROLLUP +if you want to view the source visit the plugins github repository +*/ + +'use strict'; + +var obsidian = require('obsidian'); + +/****************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ + +function __awaiter(thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +} + +function getActiveView(app) { + const activeView = app.workspace.getActiveViewOfType(obsidian.MarkdownView); + return activeView !== null && activeView !== void 0 ? activeView : undefined; +} +function isViewActive(app) { + const activeView = getActiveView(app); + if (activeView && activeView.file) + return true; + return false; +} +function getViewMetadata(app) { + const activeView = getActiveView(app); + if (activeView && activeView.file) { + const data = app.metadataCache.getFileCache(activeView.file) || {}; + return data; + } + return undefined; +} +function getViewInfo(app) { + const activeView = getActiveView(app); + const data = getViewMetadata(app); + const editor = activeView ? activeView.editor : undefined; + if (activeView && data && editor) { + return { + activeView, data, editor + }; + } + return undefined; +} + +const DEFAULT_SETTINGS = { + skipTopLevel: false, + firstLevel: 1, + maxLevel: 6, + styleLevel1: '1', + styleLevelOther: '1', + auto: false, + separator: '', + contents: '' +}; +function isValidLevelStyle(s) { + if (s === 'A' || s === '1') + return true; + return false; +} +function isValidFlag(f) { + if (f === true || f === false) + return true; + return false; +} +function isValidFirstOrMaxLevel(x) { + if (typeof x === 'number' && x >= 1 && x <= 6) + return true; + return false; +} +function isValidSeparator(x) { + if (typeof x === 'string' && (x === '' || x === ':' || x === '.' || x === '-')) + return true; + return false; +} +function isValidContents(x) { + if (typeof x === 'string' && (x === '' || x.startsWith('^'))) + return true; + return false; +} +function doesContentsHaveValue(x) { + if (x.length > 2 && x.startsWith('^')) + return true; + return false; +} + +const AUTO_PART_KEY = 'auto'; +const FIRST_LEVEL_PART_KEY = 'first-level'; +const MAX_LEVEL_PART_KEY = 'max'; +const CONTENTS_PART_KEY = 'contents'; +function parseCompactFrontMatterSettings(fm) { + const entry = obsidian.parseFrontMatterEntry(fm, 'number headings'); + if (entry) { + const entryString = String(entry); + const parts = entryString.split(','); + const settings = Object.assign({}, DEFAULT_SETTINGS); + for (const part of parts) { + const cleanPart = part.trim(); + if (cleanPart.length === 0) + continue; + if (cleanPart === AUTO_PART_KEY) { + // Parse auto numbering part + settings.auto = true; + } + else if (cleanPart.startsWith(FIRST_LEVEL_PART_KEY)) { + // Parse first level part + const nstring = cleanPart.substring(FIRST_LEVEL_PART_KEY.length + 1); + const n = parseInt(nstring); + if (isValidFirstOrMaxLevel(n)) { + settings.firstLevel = n; + } + } + else if (cleanPart.startsWith(MAX_LEVEL_PART_KEY)) { + // Parse max level part + const nstring = cleanPart.substring(MAX_LEVEL_PART_KEY.length + 1); + const n = parseInt(nstring); + if (isValidFirstOrMaxLevel(n)) { + settings.maxLevel = n; + } + } + else if (cleanPart.startsWith(CONTENTS_PART_KEY)) { + if (cleanPart.length <= CONTENTS_PART_KEY.length + 1) + continue; + // Parse contents heading part + const tocHeading = cleanPart.substring(CONTENTS_PART_KEY.length + 1); + if (isValidContents(tocHeading)) { + settings.contents = tocHeading; + } + } + else { + // Parse formatting part + const lastChar = cleanPart[cleanPart.length - 1]; + let remainingPart = cleanPart; + if (isValidSeparator(lastChar)) { + settings.separator = lastChar; + remainingPart = cleanPart.substring(0, cleanPart.length - 1); + } + const descriptors = remainingPart.split('.'); + let firstNumberedDescriptor = 0; + if (descriptors.length > 1 && descriptors[0] === '_') { + settings.skipTopLevel = true; + firstNumberedDescriptor = 1; + } + else { + settings.skipTopLevel = false; + } + if (descriptors.length - firstNumberedDescriptor >= 2) { + const styleLevel1 = descriptors[firstNumberedDescriptor]; + if (isValidLevelStyle(styleLevel1)) { + settings.styleLevel1 = styleLevel1; + } + const styleLevelOther = descriptors[firstNumberedDescriptor + 1]; + if (isValidLevelStyle(styleLevelOther)) { + settings.styleLevelOther = styleLevelOther; + } + } + } + } + return settings; + } + return undefined; +} +const getFrontMatterSettingsOrAlternative = ({ frontmatter }, alternativeSettings) => { + var _a, _b, _c, _d, _e; + if (frontmatter !== undefined) { + const decompactedSettings = parseCompactFrontMatterSettings(frontmatter); + if (decompactedSettings !== undefined) + return decompactedSettings; + // NOTE: Everything below is for backwards compatibility only + const skipTopLevelEntry = (_a = obsidian.parseFrontMatterEntry(frontmatter, 'number-headings-skip-top-level')) !== null && _a !== void 0 ? _a : obsidian.parseFrontMatterEntry(frontmatter, 'header-numbering-skip-top-level'); + const skipTopLevel = isValidFlag(skipTopLevelEntry) ? skipTopLevelEntry : alternativeSettings.skipTopLevel; + const maxLevelEntry = (_b = obsidian.parseFrontMatterEntry(frontmatter, 'number-headings-max-level')) !== null && _b !== void 0 ? _b : obsidian.parseFrontMatterEntry(frontmatter, 'header-numbering-max-level'); + const maxLevel = isValidFirstOrMaxLevel(maxLevelEntry) ? maxLevelEntry : alternativeSettings.maxLevel; + const styleLevel1Entry = String((_c = obsidian.parseFrontMatterEntry(frontmatter, 'number-headings-style-level-1')) !== null && _c !== void 0 ? _c : obsidian.parseFrontMatterEntry(frontmatter, 'header-numbering-style-level-1')); + const styleLevel1 = isValidLevelStyle(styleLevel1Entry) ? styleLevel1Entry : alternativeSettings.styleLevel1; + const styleLevelOtherEntry = String((_d = obsidian.parseFrontMatterEntry(frontmatter, 'number-headings-style-level-other')) !== null && _d !== void 0 ? _d : obsidian.parseFrontMatterEntry(frontmatter, 'header-numbering-style-level-other')); + const styleLevelOther = isValidLevelStyle(styleLevelOtherEntry) ? styleLevelOtherEntry : alternativeSettings.styleLevelOther; + const autoEntry = (_e = obsidian.parseFrontMatterEntry(frontmatter, 'number-headings-auto')) !== null && _e !== void 0 ? _e : obsidian.parseFrontMatterEntry(frontmatter, 'header-numbering-auto'); + const auto = isValidFlag(autoEntry) ? autoEntry : alternativeSettings.auto; + return Object.assign(Object.assign({}, alternativeSettings), { skipTopLevel, maxLevel, styleLevel1, styleLevelOther, auto }); + } + else { + return alternativeSettings; + } +}; +function settingsToCompactFrontMatterValue(settings) { + const autoPart = settings.auto ? 'auto, ' : ''; + const firstLevelPart = `first-level ${settings.firstLevel}, `; + const maxPart = `max ${settings.maxLevel}, `; + const contentsPart = settings.contents && settings.contents.length > 0 ? `contents ${settings.contents}, ` : ''; + const skipTopLevelString = settings.skipTopLevel ? '_.' : ''; + const stylePart = `${skipTopLevelString}${settings.styleLevel1}.${settings.styleLevelOther}${settings.separator}`; + return autoPart + firstLevelPart + maxPart + contentsPart + stylePart; +} +function findLineWhichStartsWith(editor, search, afterLine) { + // Find the location of the frontmatter + for (let i = afterLine; i < editor.lastLine(); i++) { + const lineString = editor.getLine(i); + if (lineString.startsWith(search)) { + return i; + } + } + return undefined; +} +const saveSettingsToFrontMatter = ({ frontmatter }, editor, settings) => { + if (frontmatter !== undefined) { + // Front matter already exists, so we'll need to insert the settings into the front matter + const frontMatterLine = frontmatter.position.start.line; + const v = settingsToCompactFrontMatterValue(settings); + const frontMatterAdditions = `number headings: ${v}\n`; + if (frontmatter['number headings'] !== undefined) { + // Key already present, replace it + const keyLine = findLineWhichStartsWith(editor, 'number headings', frontMatterLine); + if (keyLine === undefined) + throw new Error('Number Headings Plugin: "number headings" key exists but not found.'); + const from = { line: keyLine, ch: 0 }; + const to = { line: keyLine + 1, ch: 0 }; + editor.replaceRange(frontMatterAdditions, from, to); + } + else { + // Key not present, insert new key + const from = { line: frontMatterLine + 1, ch: 0 }; + const to = { line: frontMatterLine + 1, ch: 0 }; + editor.replaceRange(frontMatterAdditions, from, to); + } + } + else { + // No frontmatter found, create frontmatter from scratch + const v = settingsToCompactFrontMatterValue(settings); + const newFrontMatter = `---\nnumber headings: ${v}\n---\n\n`; + const from = { line: 0, ch: 0 }; + const to = { line: 0, ch: 0 }; + editor.replaceRange(newFrontMatter, from, to); + // Front matter does not exist, so we will create it from scratch + } +}; + +class NumberingDoneModal extends obsidian.Modal { + constructor(app, config) { + super(app); + this.config = config; + } + onOpen() { + const { contentEl, titleEl } = this; + titleEl.setText('Number Headings - Successfully Completed'); + contentEl.createEl('div', { text: this.config.message }); + contentEl.createEl('pre', { text: this.config.preformattedMessage }); + contentEl.createEl('div', { text: "Do you want to save these settings in the document's front matter?", cls: 'number-headings-question' }); + const containerForButtons = contentEl.createEl('div', { cls: 'number-headings-button-container' }); + const noButton = containerForButtons.createEl('button', {}); + noButton.setText('No'); + noButton.onClickEvent((ev) => { + this.close(); + return ev; + }); + const yesButton = containerForButtons.createEl('button', {}); + yesButton.setText('Yes, save settings in document'); + yesButton.onClickEvent((ev) => { + this.config.saveSettingsCallback(false); + this.close(); + return ev; + }); + const yesAndAutoButton = containerForButtons.createEl('button', {}); + yesAndAutoButton.setText('Yes, save settings in document, and automatically number'); + yesAndAutoButton.onClickEvent((ev) => { + this.config.saveSettingsCallback(true); + this.close(); + return ev; + }); + } + onClose() { + const { contentEl, titleEl } = this; + contentEl.empty(); + titleEl.empty(); + } +} +function showNumberingDoneMessage(app, settings, viewInfo) { + const saveSettingsCallback = (shouldAddAutoFlag) => { + const tweakedSettings = Object.assign({}, settings); + if (shouldAddAutoFlag) + tweakedSettings.auto = true; + saveSettingsToFrontMatter(viewInfo.data, viewInfo.editor, tweakedSettings); + }; + const config = { + message: `Successfully updated all heading numbers in the document, using the settings below. + See settings panel to change how headings are numbered, or use front matter + (see settings panel).`, + preformattedMessage: ` Skip top heading level: ${settings.skipTopLevel} +First heading level: ${settings.firstLevel} +Maximum heading level: ${settings.maxLevel} +Style for level 1 headings: ${settings.styleLevel1} +Style for lower level headings (below level 1): ${settings.styleLevelOther} +Separator: ${settings.separator} +Table of Contents Anchor: ${settings.contents}`, + saveSettingsCallback + }; + const leaf = app.workspace.activeLeaf; + if (leaf) { + new NumberingDoneModal(app, config).open(); + } +} + +const TOC_LIST_ITEM_BULLET = '-'; +function makeHeadingHashString(editor, heading) { + const regex = /^\s{0,4}#+/g; + const headingLineString = editor.getLine(heading.position.start.line); + if (!headingLineString) + return undefined; + const matches = headingLineString.match(regex); + if (!matches) + return undefined; + if (matches.length !== 1) { + // eslint-disable-next-line no-console + console.log("Unexpected heading format: '" + headingLineString + "'"); + return undefined; + } + const match = matches[0]; + return match.trimLeft(); +} +function makeNumberingString(numberingStack) { + let numberingString = ''; + for (let i = 0; i < numberingStack.length; i++) { + if (i === 0) { + numberingString += ' '; + } + else { + numberingString += '.'; + } + numberingString += numberingStack[i].toString(); + } + return numberingString; +} +function getHeadingPrefixRange(editor, heading) { + const regex = /^\s{0,4}#+( )?([0-9]+\.|[A-Z]\.)*([0-9]+|[A-Z])?[:.-]?( )+/g; + const headingLineString = editor.getLine(heading.position.start.line); + if (!headingLineString) + return undefined; + const matches = headingLineString.match(regex); + if (matches && matches.length !== 1) { + // eslint-disable-next-line no-console + console.log("Unexpected heading format: '" + headingLineString + "'"); + return undefined; + } + const match = matches ? matches[0] : ''; + const from = { + line: heading.position.start.line, + ch: 0 + }; + const to = { + line: heading.position.start.line, + ch: match.length + }; + return { from, to }; +} +function zerothNumberingTokenInStyle(style) { + if (style === '1') { + return 0; + } + else if (style === 'A') { + return 'Z'; + } + return 0; +} +function firstNumberingTokenInStyle(style) { + if (style === '1') { + return 1; + } + else if (style === 'A') { + return 'A'; + } + return 1; +} +function nextNumberingToken(t) { + if (typeof t === 'number') { + return t + 1; + } + if (typeof t === 'string') { + if (t === 'Z') + return 'A'; + else + return String.fromCharCode(t.charCodeAt(0) + 1); + } + return 1; +} +function cleanHeadingTextForToc(htext) { + if (htext.contains('^')) { + const x = htext.split('^'); + if (x.length > 1) { + return x[0].trim(); + } + } + return htext.trim(); +} +// eslint-disable-next-line @typescript-eslint/no-unused-vars +function createTocEntry(h, settings, initialHeadingLevel) { + const text = h.heading; + const cleanText = cleanHeadingTextForToc(text); + let bulletIndent = ''; + const startLevel = initialHeadingLevel; + for (let i = startLevel; i < h.level; i++) { + bulletIndent += '\t'; + } + const entryLink = `[[#${text}|${cleanText}]]`; + return bulletIndent + TOC_LIST_ITEM_BULLET + ' ' + entryLink; +} +// Replace a range, but only if there is a change in text, to prevent poluting the undo stack +function replaceRangeSafely(editor, changes, range, text) { + const previousText = editor.getRange(range.from, range.to); + if (previousText !== text) { + changes.push({ + text: text, + from: range.from, + to: range.to + }); + } +} +const updateHeadingNumbering = (viewInfo, settings) => { + var _a; + if (!viewInfo) + return; + const headings = (_a = viewInfo.data.headings) !== null && _a !== void 0 ? _a : []; + const editor = viewInfo.editor; + let previousLevel = 1; + let numberingStack = [zerothNumberingTokenInStyle(settings.styleLevel1)]; + if (settings.firstLevel > 1) { + previousLevel = settings.firstLevel; + } + else if (settings.skipTopLevel) { + previousLevel = 2; + } + const changes = []; + for (const heading of headings) { + // Update the numbering stack based on the level and previous level + const level = heading.level; + // Handle skipped & ignored levels. + if ((settings.firstLevel > level) || (settings.skipTopLevel && level === 1)) { + // Resets the numbering when a level is skipped. + // Note: This leaves headings as they are, allowing people to have numbers at the start of + // ignored headings. + numberingStack = [zerothNumberingTokenInStyle(settings.styleLevel1)]; + if (settings.firstLevel > 1) { + previousLevel = settings.firstLevel; + } + else if (settings.skipTopLevel) { + previousLevel = 2; + } + continue; + } + // Adjust numbering stack + if (level === previousLevel) { + const x = numberingStack.pop(); + if (x !== undefined) { + numberingStack.push(nextNumberingToken(x)); + } + } + else if (level < previousLevel) { + for (let i = previousLevel; i > level; i--) { + numberingStack.pop(); + } + const x = numberingStack.pop(); + if (x !== undefined) { + numberingStack.push(nextNumberingToken(x)); + } + } + else if (level > previousLevel) { + for (let i = previousLevel; i < level; i++) { + numberingStack.push(firstNumberingTokenInStyle(settings.styleLevelOther)); + } + } + // Set the previous level to this level for the next iteration + previousLevel = level; + if (level > settings.maxLevel) { + // If we are above the max level, just don't number it + continue; + } + // Find the range to replace, and then do it + const prefixRange = getHeadingPrefixRange(editor, heading); + if (prefixRange === undefined) + return; + const headingHashString = makeHeadingHashString(editor, heading); + if (headingHashString === undefined) + return; + const prefixString = makeNumberingString(numberingStack); + replaceRangeSafely(editor, changes, prefixRange, headingHashString + prefixString + settings.separator + ' '); + } + // Execute the transaction to make all the changes at once + if (changes.length > 0) { + // eslint-disable-next-line no-console + console.log('Number Headings Plugin: Applying headings numbering changes:', changes.length); + editor.transaction({ + changes: changes + }); + } +}; +const updateTableOfContents = (viewInfo, settings) => { + var _a; + if (!viewInfo) + return; + const headings = (_a = viewInfo.data.headings) !== null && _a !== void 0 ? _a : []; + const editor = viewInfo.editor; + if (!doesContentsHaveValue(settings.contents)) + return; + let tocHeading; + let tocBuilder = '\n'; + const changes = []; + // In case headings start above level 1, we don't want to indent the bullets too much + let initialHeadingLevel = 1; + if (headings.length > 0) { + initialHeadingLevel = headings[0].level; + } + for (const heading of headings) { + // ORDERING: Important to find the TOC heading before skipping skipped headings, since that is for numbering + // Find the TOC heading + if (heading.heading.endsWith(settings.contents)) { + tocHeading = heading; + } + /* This code lets us skip TOC lines for skipped headings, but doesn't work well with first-level setting + if ((settings.skipTopLevel && heading.level === 1) || (heading.level > settings.maxLevel)) { + continue + } + */ + const tocEntry = createTocEntry(heading, settings, initialHeadingLevel); + tocBuilder += tocEntry + '\n'; + } + // Insert the generated table of contents + if (tocHeading) { + const from = { + line: tocHeading.position.start.line + 1, + ch: 0 + }; + const startingLine = tocHeading.position.start.line + 1; + let endingLine = 0; + let foundList = false; + for (endingLine = startingLine;; endingLine++) { + const line = editor.getLine(endingLine); + if (line === undefined) { + // Reached end of file, insert at the start of the TOC section + endingLine = startingLine; + break; + } + const trimmedLineText = line.trimStart(); + if (foundList) { + if (!trimmedLineText.startsWith(TOC_LIST_ITEM_BULLET)) + break; + if (trimmedLineText.startsWith('#')) + break; + } + else { + if (trimmedLineText.startsWith(TOC_LIST_ITEM_BULLET)) { + foundList = true; + } + else if (trimmedLineText.startsWith('#')) { + // Reached the next heading without finding existing TOC list, insert at the start of the TOC section + endingLine = startingLine; + break; + } + else { + continue; + } + } + } + if (tocBuilder === '\n') { + tocBuilder = ''; + } + const to = { + line: endingLine, + ch: 0 + }; + const range = { from, to }; + replaceRangeSafely(editor, changes, range, tocBuilder); + } + // Execute the transaction to make all the changes at once + if (changes.length > 0) { + // eslint-disable-next-line no-console + console.log('Number Headings Plugin: Applying table of contents changes:', changes.length); + editor.transaction({ + changes: changes + }); + } +}; +const removeHeadingNumbering = (viewInfo) => { + var _a; + if (!viewInfo) + return; + const headings = (_a = viewInfo.data.headings) !== null && _a !== void 0 ? _a : []; + const editor = viewInfo.editor; + const changes = []; + for (const heading of headings) { + const prefixRange = getHeadingPrefixRange(editor, heading); + if (prefixRange === undefined) + return; + const headingHashString = makeHeadingHashString(editor, heading); + if (headingHashString === undefined) + return; + replaceRangeSafely(editor, changes, prefixRange, headingHashString + ' '); + } + if (changes.length > 0) { + editor.transaction({ + changes: changes + }); + } +}; + +class NumberHeadingsPluginSettingTab extends obsidian.PluginSettingTab { + constructor(app, plugin) { + super(app, plugin); + this.plugin = plugin; + } + display() { + const { containerEl } = this; + containerEl.empty(); + containerEl.createEl('h2', { text: 'Number Headings - Settings' }); + containerEl.createEl('div', { text: 'To add numbering to your document, bring up the command window (on Mac, type CMD+P), and then type "Number Headings" to see a list of available commands.' }); + containerEl.createEl('br', {}); + containerEl.createEl('div', { text: 'If the document has front matter defined with the below settings, the project-wide settings defined on this screen will be ignored. You can define front matter like this:' }); + containerEl.createEl('pre', { + text: ` --- + alias: + - Example Alias + tags: + - example-tag + number headings: first-level 1, max 6, 1.1, auto, contents ^toc + ---` + }); + containerEl.createEl('div', { + text: ` + The 'number headings' front matter key is used to store numbering settings specific to the file. There are four possible options + in the value to the right of the colon, separated by commas. + ` + }); + const ul = containerEl.createEl('ul', {}); + const li0 = ul.createEl('li', {}); + li0.createEl('b', { text: 'Automatic numbering' }); + li0.createEl('span', { text: ': If \'auto\' appears, the document will be automatically numbered.' }); + const li1 = ul.createEl('li', {}); + li1.createEl('b', { text: 'First level to number' }); + li1.createEl('span', { text: ': If \'first-level 2\' appears, the numbering will start at the second level' }); + const li2 = ul.createEl('li', {}); + li2.createEl('b', { text: 'Maximum level to number' }); + li2.createEl('span', { text: ': If \'max 6\' appears, the headings above level 6 will be skipped.' }); + const li3 = ul.createEl('li', {}); + li3.createEl('b', { text: 'Table of contents anchor' }); + li3.createEl('span', { text: ': If \'contents ^toc\' appears, the heading that ends with the anchor ^toc will have a table of contents inserted beneath it.' }); + const li4 = ul.createEl('li', {}); + li4.createEl('b', { text: 'Numbering style' }); + li4.createEl('span', { + text: `: + A style text like '1.1', 'A.1', or '_.1.1' tells the plugin how to format the headings. + If a style string ends with '.' (a dot), ':' (a colon), or '-' (a dash), the heading numbers will be separated from the heading title + with that symbol.` + }); + const ul3 = li4.createEl('ul', {}); + ul3.createEl('li', { + text: ` + For example, '1.1' means both top level and other headings will be numbered starting from '1'. + ` + }); + ul3.createEl('li', { + text: ` + For example, 'A.1' means top level headings will be numbered starting from 'A'. + ` + }); + ul3.createEl('li', { + text: ` + For example, '_.A.1' means top level headings will NOT be numbered, but the next levels will be numbered with letters and numbers. + ` + }); + ul3.createEl('li', { + text: ` + For example, '1.1:' means headings will look like '## 2.4: Example Heading' + ` + }); + ul3.createEl('li', { + text: ` + For example, 'A.1-' means headings will look like '## B.5- Example Heading' + ` + }); + new obsidian.Setting(containerEl) + .setName('Skip top heading level') + .setDesc('If selected, numbering will not be applied to the top heading level.') + .addToggle(toggle => toggle + .setValue(this.plugin.settings.skipTopLevel) + .setTooltip('Skip top heading level') + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.skipTopLevel = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('First heading level') + .setDesc('First heading level to number.') + .addSlider(slider => slider + .setLimits(1, 6, 1) + .setValue(this.plugin.settings.firstLevel) + .setDynamicTooltip() + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.firstLevel = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Maximum heading level') + .setDesc('Maximum heading level to number.') + .addSlider(slider => slider + .setLimits(1, 6, 1) + .setValue(this.plugin.settings.maxLevel) + .setDynamicTooltip() + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.maxLevel = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Style for level 1 headings') + .setDesc('Defines the numbering style for level one headings. Valid values are 1 (for numbers) or A (for capital letters).') + .addText(text => text + .setValue(this.plugin.settings.styleLevel1) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.styleLevel1 = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Style for lower level headings (below level 1)') + .setDesc('Defines the numbering style for headings below level one. Valid values are 1 (for numbers) or A (for capital letters).') + .addText(text => text + .setValue(this.plugin.settings.styleLevelOther) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.styleLevelOther = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Automatic numbering') + .setDesc('Turns on automatic numbering of documents.') + .addToggle(toggle => toggle + .setValue(this.plugin.settings.auto) + .setTooltip('Turn on automatic numbering') + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.auto = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Separator style') + .setDesc('Defines the separator style between the heading number and the heading text. Valid values are : (colon) or . (dot) or - (dash). You can also leave it blank for no separator.') + .addText(text => text + .setValue(this.plugin.settings.separator) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.separator = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Table of Contents Anchor') + .setDesc('Anchor which labels the header where a table of contents should be inserted. The anchor should be added at the end of a header. For example, ^toc.') + .addText(text => text + .setValue(this.plugin.settings.contents) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.contents = value; + yield this.plugin.saveSettings(); + }))); + } +} +class NumberHeadingsPlugin extends obsidian.Plugin { + onload() { + return __awaiter(this, void 0, void 0, function* () { + // eslint-disable-next-line no-console + console.info('Loading Number Headings Plugin, version ' + this.manifest.version); + yield this.loadSettings(); + this.addCommand({ + id: 'number-headings-with-options', + name: 'Number all headings in document (and show options)', + checkCallback: (checking) => { + if (checking) + return isViewActive(this.app); + const viewInfo = getViewInfo(this.app); + if (viewInfo) { + const settings = getFrontMatterSettingsOrAlternative(viewInfo.data, this.settings); + updateHeadingNumbering(viewInfo, settings); + setTimeout(() => { + // HACK: This must happen after a timeout so that there is time for the editor transaction to complete + const postNumberingViewInfo = getViewInfo(this.app); + updateTableOfContents(postNumberingViewInfo, settings); + }, 3000); + showNumberingDoneMessage(this.app, settings, viewInfo); + } + return false; + } + }); + this.addCommand({ + id: 'number-headings', + name: 'Number all headings in document', + checkCallback: (checking) => { + if (checking) + return isViewActive(this.app); + const viewInfo = getViewInfo(this.app); + if (viewInfo) { + const settings = getFrontMatterSettingsOrAlternative(viewInfo.data, this.settings); + updateHeadingNumbering(viewInfo, settings); + setTimeout(() => { + // HACK: This must happen after a timeout so that there is time for the editor transaction to complete + const postNumberingViewInfo = getViewInfo(this.app); + updateTableOfContents(postNumberingViewInfo, settings); + }, 3000); + // NOTE: The line below is intentionally commented out, since this command is the same as + // the above command, except for this line + // showNumberingDoneMessage(this.app, settings, viewInfo) + } + return false; + } + }); + this.addCommand({ + id: 'remove-number-headings', + name: 'Remove numbering from all headings in document', + checkCallback: (checking) => { + if (checking) + return isViewActive(this.app); + const viewInfo = getViewInfo(this.app); + removeHeadingNumbering(viewInfo); + return true; + } + }); + this.addCommand({ + id: 'save-settings-to-front-matter', + name: 'Save settings to front matter', + checkCallback: (checking) => { + if (checking) + return isViewActive(this.app); + const viewInfo = getViewInfo(this.app); + if (viewInfo) { + const settings = getFrontMatterSettingsOrAlternative(viewInfo.data, this.settings); + saveSettingsToFrontMatter(viewInfo.data, viewInfo.editor, settings); + } + return false; + } + }); + this.addSettingTab(new NumberHeadingsPluginSettingTab(this.app, this)); + this.registerInterval(window.setInterval(() => { + const viewInfo = getViewInfo(this.app); + if (viewInfo) { + const settings = getFrontMatterSettingsOrAlternative(viewInfo.data, this.settings); + if (settings.auto) { + updateHeadingNumbering(viewInfo, settings); + setTimeout(() => { + // HACK: This must happen after a timeout so that there is time for the editor transaction to complete + const postNumberingViewInfo = getViewInfo(this.app); + updateTableOfContents(postNumberingViewInfo, settings); + }, 3000); + // eslint-disable-next-line no-console + console.log('Number Headings Plugin: Automatically numbered document'); + } + } + }, 10 * 1000)); + }); + } + loadSettings() { + return __awaiter(this, void 0, void 0, function* () { + this.settings = Object.assign({}, DEFAULT_SETTINGS, yield this.loadData()); + }); + } + saveSettings() { + return __awaiter(this, void 0, void 0, function* () { + yield this.saveData(this.settings); + }); + } +} + +module.exports = NumberHeadingsPlugin; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["node_modules/tslib/tslib.es6.js","src/activeViewHelpers.ts","src/settingsTypes.ts","src/frontMatter.ts","src/messages.ts","src/numbering.ts","src/main.ts"],"sourcesContent":["/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n","import { App, CachedMetadata, Editor, MarkdownView } from 'obsidian'\n\nfunction getActiveView (app: App): MarkdownView | undefined {\n  const activeView = app.workspace.getActiveViewOfType(MarkdownView)\n  return activeView ?? undefined\n}\n\nexport function isViewActive (app: App): boolean {\n  const activeView = getActiveView(app)\n  if (activeView && activeView.file) return true\n  return false\n}\n\nfunction getViewMetadata (app: App): CachedMetadata | undefined {\n  const activeView = getActiveView(app)\n  if (activeView && activeView.file) {\n    const data = app.metadataCache.getFileCache(activeView.file) || {}\n    return data\n  }\n  return undefined\n}\n\nexport interface ViewInfo {\n  activeView: MarkdownView\n  data: CachedMetadata\n  editor: Editor\n}\n\nexport function getViewInfo (app: App): ViewInfo | undefined {\n  const activeView = getActiveView(app)\n  const data = getViewMetadata(app)\n  const editor = activeView ? activeView.editor : undefined\n\n  if (activeView && data && editor) {\n    return {\n      activeView, data, editor\n    }\n  }\n\n  return undefined\n}\n","export interface NumberHeadingsPluginSettings {\n  skipTopLevel: boolean,\n  firstLevel: number,\n  maxLevel: number,\n  styleLevel1: string,\n  styleLevelOther: string,\n  auto: boolean,\n  separator: string,\n  contents: string\n}\n\nexport const DEFAULT_SETTINGS: NumberHeadingsPluginSettings = {\n  skipTopLevel: false,\n  firstLevel: 1,\n  maxLevel: 6,\n  styleLevel1: '1',\n  styleLevelOther: '1',\n  auto: false,\n  separator: '',\n  contents: ''\n}\n\nexport function isValidLevelStyle (s: string): boolean {\n  if (s === 'A' || s === '1') return true\n  return false\n}\n\nexport function isValidFlag (f: unknown): boolean {\n  if (f === true || f === false) return true\n  return false\n}\n\nexport function isValidFirstOrMaxLevel (x: unknown): boolean {\n  if (typeof x === 'number' && x >= 1 && x <= 6) return true\n  return false\n}\n\nexport function isValidSeparator (x: unknown): boolean {\n  if (typeof x === 'string' && (x === '' || x === ':' || x === '.' || x === '-')) return true\n  return false\n}\n\nexport function isValidContents (x: unknown): boolean {\n  if (typeof x === 'string' && (x === '' || x.startsWith('^'))) return true\n  return false\n}\n\nexport function doesContentsHaveValue (x: string): boolean {\n  if (x.length > 2 && x.startsWith('^')) return true\n  return false\n}\n","import { CachedMetadata, Editor, EditorPosition, FrontMatterCache, parseFrontMatterEntry } from 'obsidian'\nimport { DEFAULT_SETTINGS, isValidContents, isValidFirstOrMaxLevel, isValidFlag, isValidLevelStyle, isValidSeparator, NumberHeadingsPluginSettings } from './settingsTypes'\n\nconst AUTO_PART_KEY = 'auto'\nconst FIRST_LEVEL_PART_KEY = 'first-level'\nconst MAX_LEVEL_PART_KEY = 'max'\nconst CONTENTS_PART_KEY = 'contents'\n\nfunction parseCompactFrontMatterSettings (fm: FrontMatterCache): NumberHeadingsPluginSettings | undefined {\n  const entry = parseFrontMatterEntry(fm, 'number headings')\n  if (entry) {\n    const entryString = String(entry)\n    const parts = entryString.split(',')\n    const settings: NumberHeadingsPluginSettings = { ...DEFAULT_SETTINGS }\n\n    for (const part of parts) {\n      const cleanPart = part.trim()\n      if (cleanPart.length === 0) continue\n\n      if (cleanPart === AUTO_PART_KEY) {\n        // Parse auto numbering part\n        settings.auto = true\n      } else if (cleanPart.startsWith(FIRST_LEVEL_PART_KEY)) {\n        // Parse first level part\n        const nstring = cleanPart.substring(FIRST_LEVEL_PART_KEY.length + 1)\n        const n = parseInt(nstring)\n        if (isValidFirstOrMaxLevel(n)) {\n          settings.firstLevel = n\n        }\n      } else if (cleanPart.startsWith(MAX_LEVEL_PART_KEY)) {\n        // Parse max level part\n        const nstring = cleanPart.substring(MAX_LEVEL_PART_KEY.length + 1)\n        const n = parseInt(nstring)\n        if (isValidFirstOrMaxLevel(n)) {\n          settings.maxLevel = n\n        }\n      } else if (cleanPart.startsWith(CONTENTS_PART_KEY)) {\n        if (cleanPart.length <= CONTENTS_PART_KEY.length + 1) continue\n        // Parse contents heading part\n        const tocHeading = cleanPart.substring(CONTENTS_PART_KEY.length + 1)\n        if (isValidContents(tocHeading)) {\n          settings.contents = tocHeading\n        }\n      } else {\n        // Parse formatting part\n        const lastChar = cleanPart[cleanPart.length - 1]\n        let remainingPart = cleanPart\n        if (isValidSeparator(lastChar)) {\n          settings.separator = lastChar\n          remainingPart = cleanPart.substring(0, cleanPart.length - 1)\n        }\n        const descriptors = remainingPart.split('.')\n        let firstNumberedDescriptor = 0\n        if (descriptors.length > 1 && descriptors[0] === '_') {\n          settings.skipTopLevel = true\n          firstNumberedDescriptor = 1\n        } else {\n          settings.skipTopLevel = false\n        }\n        if (descriptors.length - firstNumberedDescriptor >= 2) {\n          const styleLevel1 = descriptors[firstNumberedDescriptor]\n          if (isValidLevelStyle(styleLevel1)) {\n            settings.styleLevel1 = styleLevel1\n          }\n          const styleLevelOther = descriptors[firstNumberedDescriptor + 1]\n          if (isValidLevelStyle(styleLevelOther)) {\n            settings.styleLevelOther = styleLevelOther\n          }\n        }\n      }\n    }\n\n    return settings\n  }\n\n  return undefined\n}\n\nexport const getFrontMatterSettingsOrAlternative = (\n  { frontmatter }: CachedMetadata,\n  alternativeSettings: NumberHeadingsPluginSettings\n): NumberHeadingsPluginSettings => {\n  if (frontmatter !== undefined) {\n    const decompactedSettings = parseCompactFrontMatterSettings(frontmatter)\n    if (decompactedSettings !== undefined) return decompactedSettings\n\n    // NOTE: Everything below is for backwards compatibility only\n\n    const skipTopLevelEntry = parseFrontMatterEntry(frontmatter, 'number-headings-skip-top-level') ?? parseFrontMatterEntry(frontmatter, 'header-numbering-skip-top-level')\n    const skipTopLevel = isValidFlag(skipTopLevelEntry) ? skipTopLevelEntry : alternativeSettings.skipTopLevel\n\n    const maxLevelEntry = parseFrontMatterEntry(frontmatter, 'number-headings-max-level') ?? parseFrontMatterEntry(frontmatter, 'header-numbering-max-level')\n    const maxLevel = isValidFirstOrMaxLevel(maxLevelEntry) ? maxLevelEntry : alternativeSettings.maxLevel\n\n    const styleLevel1Entry = String(\n      parseFrontMatterEntry(frontmatter, 'number-headings-style-level-1') ??\n      parseFrontMatterEntry(frontmatter, 'header-numbering-style-level-1')\n    )\n    const styleLevel1 = isValidLevelStyle(styleLevel1Entry) ? styleLevel1Entry : alternativeSettings.styleLevel1\n\n    const styleLevelOtherEntry = String(\n      parseFrontMatterEntry(frontmatter, 'number-headings-style-level-other') ??\n      parseFrontMatterEntry(frontmatter, 'header-numbering-style-level-other')\n    )\n    const styleLevelOther = isValidLevelStyle(styleLevelOtherEntry) ? styleLevelOtherEntry : alternativeSettings.styleLevelOther\n\n    const autoEntry = parseFrontMatterEntry(frontmatter, 'number-headings-auto') ?? parseFrontMatterEntry(frontmatter, 'header-numbering-auto')\n    const auto = isValidFlag(autoEntry) ? autoEntry : alternativeSettings.auto\n\n    return { ...alternativeSettings, skipTopLevel, maxLevel, styleLevel1, styleLevelOther, auto }\n  } else {\n    return alternativeSettings\n  }\n}\n\nfunction settingsToCompactFrontMatterValue (settings: NumberHeadingsPluginSettings): string {\n  const autoPart = settings.auto ? 'auto, ' : ''\n  const firstLevelPart = `first-level ${settings.firstLevel}, `\n  const maxPart = `max ${settings.maxLevel}, `\n  const contentsPart = settings.contents && settings.contents.length > 0 ? `contents ${settings.contents}, ` : ''\n  const skipTopLevelString = settings.skipTopLevel ? '_.' : ''\n  const stylePart = `${skipTopLevelString}${settings.styleLevel1}.${settings.styleLevelOther}${settings.separator}`\n  return autoPart + firstLevelPart + maxPart + contentsPart + stylePart\n}\n\nfunction findLineWhichStartsWith (editor: Editor, search: string, afterLine: number): number | undefined {\n  // Find the location of the frontmatter\n  for (let i = afterLine; i < editor.lastLine(); i++) {\n    const lineString = editor.getLine(i)\n    if (lineString.startsWith(search)) {\n      return i\n    }\n  }\n  return undefined\n}\n\nexport const saveSettingsToFrontMatter = (\n  { frontmatter }: CachedMetadata,\n  editor: Editor,\n  settings: NumberHeadingsPluginSettings\n): void => {\n  if (frontmatter !== undefined) {\n    // Front matter already exists, so we'll need to insert the settings into the front matter\n\n    const frontMatterLine = frontmatter.position.start.line\n    const v = settingsToCompactFrontMatterValue(settings)\n    const frontMatterAdditions = `number headings: ${v}\\n`\n\n    if (frontmatter['number headings'] !== undefined) {\n      // Key already present, replace it\n      const keyLine = findLineWhichStartsWith(editor, 'number headings', frontMatterLine)\n      if (keyLine === undefined) throw new Error('Number Headings Plugin: \"number headings\" key exists but not found.')\n      const from: EditorPosition = { line: keyLine, ch: 0 }\n      const to: EditorPosition = { line: keyLine + 1, ch: 0 }\n      editor.replaceRange(frontMatterAdditions, from, to)\n    } else {\n      // Key not present, insert new key\n      const from: EditorPosition = { line: frontMatterLine + 1, ch: 0 }\n      const to: EditorPosition = { line: frontMatterLine + 1, ch: 0 }\n      editor.replaceRange(frontMatterAdditions, from, to)\n    }\n  } else {\n    // No frontmatter found, create frontmatter from scratch\n    const v = settingsToCompactFrontMatterValue(settings)\n    const newFrontMatter = `---\\nnumber headings: ${v}\\n---\\n\\n`\n    const from: EditorPosition = { line: 0, ch: 0 }\n    const to: EditorPosition = { line: 0, ch: 0 }\n    editor.replaceRange(newFrontMatter, from, to)\n    // Front matter does not exist, so we will create it from scratch\n  }\n}\n","import { App, Modal } from 'obsidian'\nimport { ViewInfo } from './activeViewHelpers'\nimport { saveSettingsToFrontMatter } from './frontMatter'\nimport { NumberHeadingsPluginSettings } from './settingsTypes'\n\nexport interface NumberingDoneConfig {\n  message: string\n  preformattedMessage: string\n  saveSettingsCallback: (shouldAddAutoFlag: boolean) => void\n}\n\nclass NumberingDoneModal extends Modal {\n  config: NumberingDoneConfig\n\n  constructor (app: App, config: NumberingDoneConfig) {\n    super(app)\n    this.config = config\n  }\n\n  onOpen (): void {\n    const { contentEl, titleEl } = this\n    titleEl.setText('Number Headings - Successfully Completed')\n\n    contentEl.createEl('div', { text: this.config.message })\n    contentEl.createEl('pre', { text: this.config.preformattedMessage })\n\n    contentEl.createEl('div', { text: \"Do you want to save these settings in the document's front matter?\", cls: 'number-headings-question' })\n\n    const containerForButtons = contentEl.createEl('div', { cls: 'number-headings-button-container' })\n\n    const noButton = containerForButtons.createEl('button', { })\n    noButton.setText('No')\n    noButton.onClickEvent((ev: MouseEvent) => {\n      this.close()\n      return ev\n    })\n\n    const yesButton = containerForButtons.createEl('button', { })\n    yesButton.setText('Yes, save settings in document')\n    yesButton.onClickEvent((ev: MouseEvent) => {\n      this.config.saveSettingsCallback(false)\n      this.close()\n      return ev\n    })\n\n    const yesAndAutoButton = containerForButtons.createEl('button', { })\n    yesAndAutoButton.setText('Yes, save settings in document, and automatically number')\n    yesAndAutoButton.onClickEvent((ev: MouseEvent) => {\n      this.config.saveSettingsCallback(true)\n      this.close()\n      return ev\n    })\n  }\n\n  onClose (): void {\n    const { contentEl, titleEl } = this\n    contentEl.empty()\n    titleEl.empty()\n  }\n}\n\nexport function showNumberingDoneMessage (app: App, settings: NumberHeadingsPluginSettings, viewInfo: ViewInfo): void {\n  const saveSettingsCallback = (shouldAddAutoFlag: boolean): void => {\n    const tweakedSettings = { ...settings }\n    if (shouldAddAutoFlag) tweakedSettings.auto = true\n    saveSettingsToFrontMatter(viewInfo.data, viewInfo.editor, tweakedSettings)\n  }\n  const config: NumberingDoneConfig = {\n    message: `Successfully updated all heading numbers in the document, using the settings below. \n      See settings panel to change how headings are numbered, or use front matter\n      (see settings panel).`,\n    preformattedMessage: `  Skip top heading level: ${settings.skipTopLevel}\nFirst heading level: ${settings.firstLevel}\nMaximum heading level: ${settings.maxLevel}\nStyle for level 1 headings: ${settings.styleLevel1}\nStyle for lower level headings (below level 1): ${settings.styleLevelOther}\nSeparator: ${settings.separator}\nTable of Contents Anchor: ${settings.contents}`,\n    saveSettingsCallback\n  }\n\n  const leaf = app.workspace.activeLeaf\n  if (leaf) {\n    new NumberingDoneModal(app, config).open()\n  }\n}\n","import { Editor, EditorChange, EditorRange, HeadingCache } from 'obsidian'\nimport { ViewInfo } from './activeViewHelpers'\nimport { doesContentsHaveValue, NumberHeadingsPluginSettings } from './settingsTypes'\n\nconst TOC_LIST_ITEM_BULLET = '-'\n\nfunction makeHeadingHashString (editor: Editor, heading: HeadingCache): string | undefined {\n  const regex = /^\\s{0,4}#+/g\n  const headingLineString = editor.getLine(heading.position.start.line)\n  if (!headingLineString) return undefined\n\n  const matches = headingLineString.match(regex)\n  if (!matches) return undefined\n\n  if (matches.length !== 1) {\n    // eslint-disable-next-line no-console\n    console.log(\"Unexpected heading format: '\" + headingLineString + \"'\")\n    return undefined\n  }\n\n  const match = matches[0]\n  return match.trimLeft()\n}\n\nfunction makeNumberingString (numberingStack: NumberingToken[]): string {\n  let numberingString = ''\n\n  for (let i = 0; i < numberingStack.length; i++) {\n    if (i === 0) {\n      numberingString += ' '\n    } else {\n      numberingString += '.'\n    }\n    numberingString += numberingStack[i].toString()\n  }\n\n  return numberingString\n}\n\nfunction getHeadingPrefixRange (editor: Editor, heading: HeadingCache): EditorRange | undefined {\n  const regex = /^\\s{0,4}#+( )?([0-9]+\\.|[A-Z]\\.)*([0-9]+|[A-Z])?[:.-]?( )+/g\n  const headingLineString = editor.getLine(heading.position.start.line)\n  if (!headingLineString) return undefined\n\n  const matches = headingLineString.match(regex)\n\n  if (matches && matches.length !== 1) {\n    // eslint-disable-next-line no-console\n    console.log(\"Unexpected heading format: '\" + headingLineString + \"'\")\n    return undefined\n  }\n\n  const match = matches ? matches[0] : ''\n\n  const from = {\n    line: heading.position.start.line,\n    ch: 0\n  }\n  const to = {\n    line: heading.position.start.line,\n    ch: match.length\n  }\n\n  return { from, to }\n}\n\ntype NumberingToken = string | number\n\nfunction zerothNumberingTokenInStyle (style: string): NumberingToken {\n  if (style === '1') {\n    return 0\n  } else if (style === 'A') {\n    return 'Z'\n  }\n\n  return 0\n}\n\nfunction firstNumberingTokenInStyle (style: string): NumberingToken {\n  if (style === '1') {\n    return 1\n  } else if (style === 'A') {\n    return 'A'\n  }\n\n  return 1\n}\n\nfunction nextNumberingToken (t: NumberingToken): NumberingToken {\n  if (typeof t === 'number') {\n    return t + 1\n  }\n\n  if (typeof t === 'string') {\n    if (t === 'Z') return 'A'\n    else return String.fromCharCode(t.charCodeAt(0) + 1)\n  }\n\n  return 1\n}\n\nfunction cleanHeadingTextForToc (htext: string): string {\n  if (htext.contains('^')) {\n    const x = htext.split('^')\n    if (x.length > 1) {\n      return x[0].trim()\n    }\n  }\n  return htext.trim()\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction createTocEntry (h: HeadingCache, settings: NumberHeadingsPluginSettings, initialHeadingLevel: number):string {\n  const text = h.heading\n  const cleanText = cleanHeadingTextForToc(text)\n\n  let bulletIndent = ''\n  const startLevel = initialHeadingLevel\n  for (let i = startLevel; i < h.level; i++) {\n    bulletIndent += '\\t'\n  }\n\n  const entryLink = `[[#${text}|${cleanText}]]`\n\n  return bulletIndent + TOC_LIST_ITEM_BULLET + ' ' + entryLink\n}\n\n// Replace a range, but only if there is a change in text, to prevent poluting the undo stack\nfunction replaceRangeSafely (editor: Editor, changes: EditorChange[], range: EditorRange, text: string): void {\n  const previousText = editor.getRange(range.from, range.to)\n\n  if (previousText !== text) {\n    changes.push({\n      text: text,\n      from: range.from,\n      to: range.to\n    })\n  }\n}\n\nexport const updateHeadingNumbering = (\n  viewInfo: ViewInfo | undefined,\n  settings: NumberHeadingsPluginSettings\n): void => {\n  if (!viewInfo) return\n  const headings = viewInfo.data.headings ?? []\n  const editor = viewInfo.editor\n\n  let previousLevel = 1\n\n  let numberingStack: NumberingToken[] = [zerothNumberingTokenInStyle(settings.styleLevel1)]\n\n  if (settings.firstLevel > 1) {\n    previousLevel = settings.firstLevel\n  } else if (settings.skipTopLevel) {\n    previousLevel = 2\n  }\n\n  const changes: EditorChange[] = []\n\n  for (const heading of headings) {\n    // Update the numbering stack based on the level and previous level\n\n    const level = heading.level\n\n    // Handle skipped & ignored levels.\n    if ((settings.firstLevel > level) || (settings.skipTopLevel && level === 1)) {\n      // Resets the numbering when a level is skipped.\n      // Note: This leaves headings as they are, allowing people to have numbers at the start of\n      // ignored headings.\n\n      numberingStack = [zerothNumberingTokenInStyle(settings.styleLevel1)]\n\n      if (settings.firstLevel > 1) {\n        previousLevel = settings.firstLevel\n      } else if (settings.skipTopLevel) {\n        previousLevel = 2\n      }\n      continue\n    }\n\n    // Adjust numbering stack\n    if (level === previousLevel) {\n      const x = numberingStack.pop()\n      if (x !== undefined) {\n        numberingStack.push(nextNumberingToken(x))\n      }\n    } else if (level < previousLevel) {\n      for (let i = previousLevel; i > level; i--) {\n        numberingStack.pop()\n      }\n      const x = numberingStack.pop()\n      if (x !== undefined) {\n        numberingStack.push(nextNumberingToken(x))\n      }\n    } else if (level > previousLevel) {\n      for (let i = previousLevel; i < level; i++) {\n        numberingStack.push(firstNumberingTokenInStyle(settings.styleLevelOther))\n      }\n    }\n\n    // Set the previous level to this level for the next iteration\n    previousLevel = level\n\n    if (level > settings.maxLevel) {\n      // If we are above the max level, just don't number it\n      continue\n    }\n\n    // Find the range to replace, and then do it\n    const prefixRange = getHeadingPrefixRange(editor, heading)\n    if (prefixRange === undefined) return\n    const headingHashString = makeHeadingHashString(editor, heading)\n    if (headingHashString === undefined) return\n    const prefixString = makeNumberingString(numberingStack)\n    replaceRangeSafely(editor, changes, prefixRange, headingHashString + prefixString + settings.separator + ' ')\n  }\n\n  // Execute the transaction to make all the changes at once\n  if (changes.length > 0) {\n    // eslint-disable-next-line no-console\n    console.log('Number Headings Plugin: Applying headings numbering changes:', changes.length)\n    editor.transaction({\n      changes: changes\n    })\n  }\n}\n\nexport const updateTableOfContents = (\n  viewInfo: ViewInfo | undefined,\n  settings: NumberHeadingsPluginSettings\n): void => {\n  if (!viewInfo) return\n  const headings = viewInfo.data.headings ?? []\n  const editor = viewInfo.editor\n\n  if (!doesContentsHaveValue(settings.contents)) return\n\n  let tocHeading: HeadingCache | undefined\n  let tocBuilder = '\\n'\n  const changes: EditorChange[] = []\n\n  // In case headings start above level 1, we don't want to indent the bullets too much\n  let initialHeadingLevel = 1\n  if (headings.length > 0) {\n    initialHeadingLevel = headings[0].level\n  }\n\n  for (const heading of headings) {\n    // ORDERING: Important to find the TOC heading before skipping skipped headings, since that is for numbering\n\n    // Find the TOC heading\n    if (heading.heading.endsWith(settings.contents)) {\n      tocHeading = heading\n    }\n\n    /* This code lets us skip TOC lines for skipped headings, but doesn't work well with first-level setting\n    if ((settings.skipTopLevel && heading.level === 1) || (heading.level > settings.maxLevel)) {\n      continue\n    }\n    */\n\n    const tocEntry = createTocEntry(heading, settings, initialHeadingLevel)\n    tocBuilder += tocEntry + '\\n'\n  }\n\n  // Insert the generated table of contents\n  if (tocHeading) {\n    const from = {\n      line: tocHeading.position.start.line + 1,\n      ch: 0\n    }\n\n    const startingLine = tocHeading.position.start.line + 1\n    let endingLine = 0\n    let foundList = false\n    for (endingLine = startingLine; ; endingLine++) {\n      const line = editor.getLine(endingLine)\n      if (line === undefined) {\n        // Reached end of file, insert at the start of the TOC section\n        endingLine = startingLine\n        break\n      }\n      const trimmedLineText = line.trimStart()\n      if (foundList) {\n        if (!trimmedLineText.startsWith(TOC_LIST_ITEM_BULLET)) break\n        if (trimmedLineText.startsWith('#')) break\n      } else {\n        if (trimmedLineText.startsWith(TOC_LIST_ITEM_BULLET)) {\n          foundList = true\n        } else if (trimmedLineText.startsWith('#')) {\n          // Reached the next heading without finding existing TOC list, insert at the start of the TOC section\n          endingLine = startingLine\n          break\n        } else {\n          continue\n        }\n      }\n    }\n\n    if (tocBuilder === '\\n') {\n      tocBuilder = ''\n    }\n\n    const to = {\n      line: endingLine,\n      ch: 0\n    }\n    const range = { from, to }\n    replaceRangeSafely(editor, changes, range, tocBuilder)\n  }\n\n  // Execute the transaction to make all the changes at once\n  if (changes.length > 0) {\n    // eslint-disable-next-line no-console\n    console.log('Number Headings Plugin: Applying table of contents changes:', changes.length)\n    editor.transaction({\n      changes: changes\n    })\n  }\n}\n\nexport const removeHeadingNumbering = (\n  viewInfo: ViewInfo | undefined\n): void => {\n  if (!viewInfo) return\n  const headings = viewInfo.data.headings ?? []\n  const editor = viewInfo.editor\n\n  const changes: EditorChange[] = []\n\n  for (const heading of headings) {\n    const prefixRange = getHeadingPrefixRange(editor, heading)\n    if (prefixRange === undefined) return\n    const headingHashString = makeHeadingHashString(editor, heading)\n    if (headingHashString === undefined) return\n    replaceRangeSafely(editor, changes, prefixRange, headingHashString + ' ')\n  }\n\n  if (changes.length > 0) {\n    editor.transaction({\n      changes: changes\n    })\n  }\n}\n","import { App, Plugin, PluginSettingTab, Setting } from 'obsidian'\r\nimport { getViewInfo, isViewActive } from './activeViewHelpers'\r\nimport { getFrontMatterSettingsOrAlternative, saveSettingsToFrontMatter } from './frontMatter'\r\nimport { showNumberingDoneMessage } from './messages'\r\nimport { removeHeadingNumbering, updateHeadingNumbering, updateTableOfContents } from './numbering'\r\nimport { DEFAULT_SETTINGS, NumberHeadingsPluginSettings } from './settingsTypes'\r\n\r\nclass NumberHeadingsPluginSettingTab extends PluginSettingTab {\r\n  plugin: NumberHeadingsPlugin\r\n\r\n  constructor (app: App, plugin: NumberHeadingsPlugin) {\r\n    super(app, plugin)\r\n    this.plugin = plugin\r\n  }\r\n\r\n  display (): void {\r\n    const { containerEl } = this\r\n\r\n    containerEl.empty()\r\n\r\n    containerEl.createEl('h2', { text: 'Number Headings - Settings' })\r\n\r\n    containerEl.createEl('div', { text: 'To add numbering to your document, bring up the command window (on Mac, type CMD+P), and then type \"Number Headings\" to see a list of available commands.' })\r\n\r\n    containerEl.createEl('br', {})\r\n\r\n    containerEl.createEl('div', { text: 'If the document has front matter defined with the below settings, the project-wide settings defined on this screen will be ignored. You can define front matter like this:' })\r\n\r\n    containerEl.createEl('pre', {\r\n      text: `    ---\r\n    alias:\r\n    - Example Alias\r\n    tags:\r\n    - example-tag\r\n    number headings: first-level 1, max 6, 1.1, auto, contents ^toc\r\n    ---`\r\n    })\r\n\r\n    containerEl.createEl('div', {\r\n      text: `\r\n      The 'number headings' front matter key is used to store numbering settings specific to the file. There are four possible options\r\n      in the value to the right of the colon, separated by commas.\r\n    `\r\n    })\r\n\r\n    const ul = containerEl.createEl('ul', {})\r\n\r\n    const li0 = ul.createEl('li', { })\r\n    li0.createEl('b', { text: 'Automatic numbering' })\r\n    li0.createEl('span', { text: ': If \\'auto\\' appears, the document will be automatically numbered.' })\r\n\r\n    const li1 = ul.createEl('li', { })\r\n    li1.createEl('b', { text: 'First level to number' })\r\n    li1.createEl('span', { text: ': If \\'first-level 2\\' appears, the numbering will start at the second level' })\r\n\r\n    const li2 = ul.createEl('li', { })\r\n    li2.createEl('b', { text: 'Maximum level to number' })\r\n    li2.createEl('span', { text: ': If \\'max 6\\' appears, the headings above level 6 will be skipped.' })\r\n\r\n    const li3 = ul.createEl('li', { })\r\n    li3.createEl('b', { text: 'Table of contents anchor' })\r\n    li3.createEl('span', { text: ': If \\'contents ^toc\\' appears, the heading that ends with the anchor ^toc will have a table of contents inserted beneath it.' })\r\n\r\n    const li4 = ul.createEl('li', { })\r\n    li4.createEl('b', { text: 'Numbering style' })\r\n    li4.createEl('span', {\r\n      text: `:\r\n      A style text like '1.1', 'A.1', or '_.1.1' tells the plugin how to format the headings.\r\n      If a style string ends with '.' (a dot), ':' (a colon), or '-' (a dash), the heading numbers will be separated from the heading title\r\n      with that symbol.`\r\n    })\r\n\r\n    const ul3 = li4.createEl('ul', {})\r\n    ul3.createEl('li', {\r\n      text: `      \r\n      For example, '1.1' means both top level and other headings will be numbered starting from '1'.\r\n    `\r\n    })\r\n    ul3.createEl('li', {\r\n      text: `      \r\n      For example, 'A.1' means top level headings will be numbered starting from 'A'.\r\n    `\r\n    })\r\n    ul3.createEl('li', {\r\n      text: `      \r\n      For example, '_.A.1' means top level headings will NOT be numbered, but the next levels will be numbered with letters and numbers.\r\n    `\r\n    })\r\n    ul3.createEl('li', {\r\n      text: `      \r\n      For example, '1.1:' means headings will look like '## 2.4: Example Heading'\r\n    `\r\n    })\r\n    ul3.createEl('li', {\r\n      text: `      \r\n      For example, 'A.1-' means headings will look like '## B.5- Example Heading'\r\n    `\r\n    })\r\n\r\n    new Setting(containerEl)\r\n      .setName('Skip top heading level')\r\n      .setDesc('If selected, numbering will not be applied to the top heading level.')\r\n      .addToggle(toggle => toggle\r\n        .setValue(this.plugin.settings.skipTopLevel)\r\n        .setTooltip('Skip top heading level')\r\n        .onChange(async (value) => {\r\n          this.plugin.settings.skipTopLevel = value\r\n          await this.plugin.saveSettings()\r\n        }))\r\n\r\n    new Setting(containerEl)\r\n      .setName('First heading level')\r\n      .setDesc('First heading level to number.')\r\n      .addSlider(slider => slider\r\n        .setLimits(1, 6, 1)\r\n        .setValue(this.plugin.settings.firstLevel)\r\n        .setDynamicTooltip()\r\n        .onChange(async (value) => {\r\n          this.plugin.settings.firstLevel = value\r\n          await this.plugin.saveSettings()\r\n        }))\r\n\r\n    new Setting(containerEl)\r\n      .setName('Maximum heading level')\r\n      .setDesc('Maximum heading level to number.')\r\n      .addSlider(slider => slider\r\n        .setLimits(1, 6, 1)\r\n        .setValue(this.plugin.settings.maxLevel)\r\n        .setDynamicTooltip()\r\n        .onChange(async (value) => {\r\n          this.plugin.settings.maxLevel = value\r\n          await this.plugin.saveSettings()\r\n        }))\r\n\r\n    new Setting(containerEl)\r\n      .setName('Style for level 1 headings')\r\n      .setDesc('Defines the numbering style for level one headings. Valid values are 1 (for numbers) or A (for capital letters).')\r\n      .addText(text => text\r\n        .setValue(this.plugin.settings.styleLevel1)\r\n        .onChange(async (value) => {\r\n          this.plugin.settings.styleLevel1 = value\r\n          await this.plugin.saveSettings()\r\n        }))\r\n\r\n    new Setting(containerEl)\r\n      .setName('Style for lower level headings (below level 1)')\r\n      .setDesc('Defines the numbering style for headings below level one. Valid values are 1 (for numbers) or A (for capital letters).')\r\n      .addText(text => text\r\n        .setValue(this.plugin.settings.styleLevelOther)\r\n        .onChange(async (value) => {\r\n          this.plugin.settings.styleLevelOther = value\r\n          await this.plugin.saveSettings()\r\n        }))\r\n\r\n    new Setting(containerEl)\r\n      .setName('Automatic numbering')\r\n      .setDesc('Turns on automatic numbering of documents.')\r\n      .addToggle(toggle => toggle\r\n        .setValue(this.plugin.settings.auto)\r\n        .setTooltip('Turn on automatic numbering')\r\n        .onChange(async (value) => {\r\n          this.plugin.settings.auto = value\r\n          await this.plugin.saveSettings()\r\n        }))\r\n\r\n    new Setting(containerEl)\r\n      .setName('Separator style')\r\n      .setDesc('Defines the separator style between the heading number and the heading text. Valid values are : (colon) or . (dot) or - (dash). You can also leave it blank for no separator.')\r\n      .addText(text => text\r\n        .setValue(this.plugin.settings.separator)\r\n        .onChange(async (value) => {\r\n          this.plugin.settings.separator = value\r\n          await this.plugin.saveSettings()\r\n        }))\r\n\r\n    new Setting(containerEl)\r\n      .setName('Table of Contents Anchor')\r\n      .setDesc('Anchor which labels the header where a table of contents should be inserted. The anchor should be added at the end of a header. For example, ^toc.')\r\n      .addText(text => text\r\n        .setValue(this.plugin.settings.contents)\r\n        .onChange(async (value) => {\r\n          this.plugin.settings.contents = value\r\n          await this.plugin.saveSettings()\r\n        }))\r\n  }\r\n}\r\n\r\nexport default class NumberHeadingsPlugin extends Plugin {\r\n  settings!: NumberHeadingsPluginSettings\r\n\r\n  async onload (): Promise<void> {\r\n    // eslint-disable-next-line no-console\r\n    console.info('Loading Number Headings Plugin, version ' + this.manifest.version)\r\n\r\n    await this.loadSettings()\r\n\r\n    this.addCommand({\r\n      id: 'number-headings-with-options',\r\n      name: 'Number all headings in document (and show options)',\r\n      checkCallback: (checking: boolean) => {\r\n        if (checking) return isViewActive(this.app)\r\n\r\n        const viewInfo = getViewInfo(this.app)\r\n        if (viewInfo) {\r\n          const settings = getFrontMatterSettingsOrAlternative(viewInfo.data, this.settings)\r\n          updateHeadingNumbering(viewInfo, settings)\r\n          setTimeout(() => {\r\n            // HACK: This must happen after a timeout so that there is time for the editor transaction to complete\r\n            const postNumberingViewInfo = getViewInfo(this.app)\r\n            updateTableOfContents(postNumberingViewInfo, settings)\r\n          }, 3000)\r\n\r\n          showNumberingDoneMessage(this.app, settings, viewInfo)\r\n        }\r\n\r\n        return false\r\n      }\r\n    })\r\n\r\n    this.addCommand({\r\n      id: 'number-headings',\r\n      name: 'Number all headings in document',\r\n      checkCallback: (checking: boolean) => {\r\n        if (checking) return isViewActive(this.app)\r\n\r\n        const viewInfo = getViewInfo(this.app)\r\n        if (viewInfo) {\r\n          const settings = getFrontMatterSettingsOrAlternative(viewInfo.data, this.settings)\r\n          updateHeadingNumbering(viewInfo, settings)\r\n          setTimeout(() => {\r\n            // HACK: This must happen after a timeout so that there is time for the editor transaction to complete\r\n            const postNumberingViewInfo = getViewInfo(this.app)\r\n            updateTableOfContents(postNumberingViewInfo, settings)\r\n          }, 3000)\r\n\r\n          // NOTE: The line below is intentionally commented out, since this command is the same as\r\n          //       the above command, except for this line\r\n          // showNumberingDoneMessage(this.app, settings, viewInfo)\r\n        }\r\n\r\n        return false\r\n      }\r\n    })\r\n\r\n    this.addCommand({\r\n      id: 'remove-number-headings',\r\n      name: 'Remove numbering from all headings in document',\r\n      checkCallback: (checking: boolean) => {\r\n        if (checking) return isViewActive(this.app)\r\n\r\n        const viewInfo = getViewInfo(this.app)\r\n        removeHeadingNumbering(viewInfo)\r\n\r\n        return true\r\n      }\r\n    })\r\n\r\n    this.addCommand({\r\n      id: 'save-settings-to-front-matter',\r\n      name: 'Save settings to front matter',\r\n      checkCallback: (checking: boolean) => {\r\n        if (checking) return isViewActive(this.app)\r\n\r\n        const viewInfo = getViewInfo(this.app)\r\n        if (viewInfo) {\r\n          const settings = getFrontMatterSettingsOrAlternative(viewInfo.data, this.settings)\r\n          saveSettingsToFrontMatter(viewInfo.data, viewInfo.editor, settings)\r\n        }\r\n\r\n        return false\r\n      }\r\n    })\r\n\r\n    this.addSettingTab(new NumberHeadingsPluginSettingTab(this.app, this))\r\n\r\n    this.registerInterval(window.setInterval(() => {\r\n      const viewInfo = getViewInfo(this.app)\r\n      if (viewInfo) {\r\n        const settings = getFrontMatterSettingsOrAlternative(viewInfo.data, this.settings)\r\n\r\n        if (settings.auto) {\r\n          updateHeadingNumbering(viewInfo, settings)\r\n          setTimeout(() => {\r\n            // HACK: This must happen after a timeout so that there is time for the editor transaction to complete\r\n            const postNumberingViewInfo = getViewInfo(this.app)\r\n            updateTableOfContents(postNumberingViewInfo, settings)\r\n          }, 3000)\r\n          // eslint-disable-next-line no-console\r\n          console.log('Number Headings Plugin: Automatically numbered document')\r\n        }\r\n      }\r\n    }, 10 * 1000))\r\n  }\r\n\r\n  async loadSettings (): Promise<void> {\r\n    this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData())\r\n  }\r\n\r\n  async saveSettings (): Promise<void> {\r\n    await this.saveData(this.settings)\r\n  }\r\n}\r\n"],"names":["MarkdownView","parseFrontMatterEntry","Modal","PluginSettingTab","Setting","Plugin"],"mappings":";;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAuDA;AACO,SAAS,SAAS,CAAC,OAAO,EAAE,UAAU,EAAE,CAAC,EAAE,SAAS,EAAE;AAC7D,IAAI,SAAS,KAAK,CAAC,KAAK,EAAE,EAAE,OAAO,KAAK,YAAY,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC,CAAC,UAAU,OAAO,EAAE,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE;AAChH,IAAI,OAAO,KAAK,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,EAAE,UAAU,OAAO,EAAE,MAAM,EAAE;AAC/D,QAAQ,SAAS,SAAS,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE;AACnG,QAAQ,SAAS,QAAQ,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE;AACtG,QAAQ,SAAS,IAAI,CAAC,MAAM,EAAE,EAAE,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC,EAAE;AACtH,QAAQ,IAAI,CAAC,CAAC,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,OAAO,EAAE,UAAU,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9E,KAAK,CAAC,CAAC;AACP;;AC3EA,SAAS,aAAa,CAAE,GAAQ,EAAA;IAC9B,MAAM,UAAU,GAAG,GAAG,CAAC,SAAS,CAAC,mBAAmB,CAACA,qBAAY,CAAC,CAAA;AAClE,IAAA,OAAO,UAAU,KAAV,IAAA,IAAA,UAAU,cAAV,UAAU,GAAI,SAAS,CAAA;AAChC,CAAC;AAEK,SAAU,YAAY,CAAE,GAAQ,EAAA;AACpC,IAAA,MAAM,UAAU,GAAG,aAAa,CAAC,GAAG,CAAC,CAAA;AACrC,IAAA,IAAI,UAAU,IAAI,UAAU,CAAC,IAAI;AAAE,QAAA,OAAO,IAAI,CAAA;AAC9C,IAAA,OAAO,KAAK,CAAA;AACd,CAAC;AAED,SAAS,eAAe,CAAE,GAAQ,EAAA;AAChC,IAAA,MAAM,UAAU,GAAG,aAAa,CAAC,GAAG,CAAC,CAAA;AACrC,IAAA,IAAI,UAAU,IAAI,UAAU,CAAC,IAAI,EAAE;AACjC,QAAA,MAAM,IAAI,GAAG,GAAG,CAAC,aAAa,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,CAAA;AAClE,QAAA,OAAO,IAAI,CAAA;AACZ,KAAA;AACD,IAAA,OAAO,SAAS,CAAA;AAClB,CAAC;AAQK,SAAU,WAAW,CAAE,GAAQ,EAAA;AACnC,IAAA,MAAM,UAAU,GAAG,aAAa,CAAC,GAAG,CAAC,CAAA;AACrC,IAAA,MAAM,IAAI,GAAG,eAAe,CAAC,GAAG,CAAC,CAAA;AACjC,IAAA,MAAM,MAAM,GAAG,UAAU,GAAG,UAAU,CAAC,MAAM,GAAG,SAAS,CAAA;AAEzD,IAAA,IAAI,UAAU,IAAI,IAAI,IAAI,MAAM,EAAE;QAChC,OAAO;YACL,UAAU,EAAE,IAAI,EAAE,MAAM;SACzB,CAAA;AACF,KAAA;AAED,IAAA,OAAO,SAAS,CAAA;AAClB;;AC7BO,MAAM,gBAAgB,GAAiC;AAC5D,IAAA,YAAY,EAAE,KAAK;AACnB,IAAA,UAAU,EAAE,CAAC;AACb,IAAA,QAAQ,EAAE,CAAC;AACX,IAAA,WAAW,EAAE,GAAG;AAChB,IAAA,eAAe,EAAE,GAAG;AACpB,IAAA,IAAI,EAAE,KAAK;AACX,IAAA,SAAS,EAAE,EAAE;AACb,IAAA,QAAQ,EAAE,EAAE;CACb,CAAA;AAEK,SAAU,iBAAiB,CAAE,CAAS,EAAA;AAC1C,IAAA,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG;AAAE,QAAA,OAAO,IAAI,CAAA;AACvC,IAAA,OAAO,KAAK,CAAA;AACd,CAAC;AAEK,SAAU,WAAW,CAAE,CAAU,EAAA;AACrC,IAAA,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,KAAK;AAAE,QAAA,OAAO,IAAI,CAAA;AAC1C,IAAA,OAAO,KAAK,CAAA;AACd,CAAC;AAEK,SAAU,sBAAsB,CAAE,CAAU,EAAA;IAChD,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;AAAE,QAAA,OAAO,IAAI,CAAA;AAC1D,IAAA,OAAO,KAAK,CAAA;AACd,CAAC;AAEK,SAAU,gBAAgB,CAAE,CAAU,EAAA;IAC1C,IAAI,OAAO,CAAC,KAAK,QAAQ,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,CAAC;AAAE,QAAA,OAAO,IAAI,CAAA;AAC3F,IAAA,OAAO,KAAK,CAAA;AACd,CAAC;AAEK,SAAU,eAAe,CAAE,CAAU,EAAA;AACzC,IAAA,IAAI,OAAO,CAAC,KAAK,QAAQ,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;AAAE,QAAA,OAAO,IAAI,CAAA;AACzE,IAAA,OAAO,KAAK,CAAA;AACd,CAAC;AAEK,SAAU,qBAAqB,CAAE,CAAS,EAAA;IAC9C,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC;AAAE,QAAA,OAAO,IAAI,CAAA;AAClD,IAAA,OAAO,KAAK,CAAA;AACd;;AC/CA,MAAM,aAAa,GAAG,MAAM,CAAA;AAC5B,MAAM,oBAAoB,GAAG,aAAa,CAAA;AAC1C,MAAM,kBAAkB,GAAG,KAAK,CAAA;AAChC,MAAM,iBAAiB,GAAG,UAAU,CAAA;AAEpC,SAAS,+BAA+B,CAAE,EAAoB,EAAA;IAC5D,MAAM,KAAK,GAAGC,8BAAqB,CAAC,EAAE,EAAE,iBAAiB,CAAC,CAAA;AAC1D,IAAA,IAAI,KAAK,EAAE;AACT,QAAA,MAAM,WAAW,GAAG,MAAM,CAAC,KAAK,CAAC,CAAA;QACjC,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;AACpC,QAAA,MAAM,QAAQ,GAAA,MAAA,CAAA,MAAA,CAAA,EAAA,EAAsC,gBAAgB,CAAE,CAAA;AAEtE,QAAA,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;AACxB,YAAA,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,EAAE,CAAA;AAC7B,YAAA,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;gBAAE,SAAQ;YAEpC,IAAI,SAAS,KAAK,aAAa,EAAE;;AAE/B,gBAAA,QAAQ,CAAC,IAAI,GAAG,IAAI,CAAA;AACrB,aAAA;AAAM,iBAAA,IAAI,SAAS,CAAC,UAAU,CAAC,oBAAoB,CAAC,EAAE;;AAErD,gBAAA,MAAM,OAAO,GAAG,SAAS,CAAC,SAAS,CAAC,oBAAoB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;AACpE,gBAAA,MAAM,CAAC,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAA;AAC3B,gBAAA,IAAI,sBAAsB,CAAC,CAAC,CAAC,EAAE;AAC7B,oBAAA,QAAQ,CAAC,UAAU,GAAG,CAAC,CAAA;AACxB,iBAAA;AACF,aAAA;AAAM,iBAAA,IAAI,SAAS,CAAC,UAAU,CAAC,kBAAkB,CAAC,EAAE;;AAEnD,gBAAA,MAAM,OAAO,GAAG,SAAS,CAAC,SAAS,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;AAClE,gBAAA,MAAM,CAAC,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAA;AAC3B,gBAAA,IAAI,sBAAsB,CAAC,CAAC,CAAC,EAAE;AAC7B,oBAAA,QAAQ,CAAC,QAAQ,GAAG,CAAC,CAAA;AACtB,iBAAA;AACF,aAAA;AAAM,iBAAA,IAAI,SAAS,CAAC,UAAU,CAAC,iBAAiB,CAAC,EAAE;gBAClD,IAAI,SAAS,CAAC,MAAM,IAAI,iBAAiB,CAAC,MAAM,GAAG,CAAC;oBAAE,SAAQ;;AAE9D,gBAAA,MAAM,UAAU,GAAG,SAAS,CAAC,SAAS,CAAC,iBAAiB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;AACpE,gBAAA,IAAI,eAAe,CAAC,UAAU,CAAC,EAAE;AAC/B,oBAAA,QAAQ,CAAC,QAAQ,GAAG,UAAU,CAAA;AAC/B,iBAAA;AACF,aAAA;AAAM,iBAAA;;gBAEL,MAAM,QAAQ,GAAG,SAAS,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;gBAChD,IAAI,aAAa,GAAG,SAAS,CAAA;AAC7B,gBAAA,IAAI,gBAAgB,CAAC,QAAQ,CAAC,EAAE;AAC9B,oBAAA,QAAQ,CAAC,SAAS,GAAG,QAAQ,CAAA;AAC7B,oBAAA,aAAa,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;AAC7D,iBAAA;gBACD,MAAM,WAAW,GAAG,aAAa,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;gBAC5C,IAAI,uBAAuB,GAAG,CAAC,CAAA;AAC/B,gBAAA,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE;AACpD,oBAAA,QAAQ,CAAC,YAAY,GAAG,IAAI,CAAA;oBAC5B,uBAAuB,GAAG,CAAC,CAAA;AAC5B,iBAAA;AAAM,qBAAA;AACL,oBAAA,QAAQ,CAAC,YAAY,GAAG,KAAK,CAAA;AAC9B,iBAAA;AACD,gBAAA,IAAI,WAAW,CAAC,MAAM,GAAG,uBAAuB,IAAI,CAAC,EAAE;AACrD,oBAAA,MAAM,WAAW,GAAG,WAAW,CAAC,uBAAuB,CAAC,CAAA;AACxD,oBAAA,IAAI,iBAAiB,CAAC,WAAW,CAAC,EAAE;AAClC,wBAAA,QAAQ,CAAC,WAAW,GAAG,WAAW,CAAA;AACnC,qBAAA;oBACD,MAAM,eAAe,GAAG,WAAW,CAAC,uBAAuB,GAAG,CAAC,CAAC,CAAA;AAChE,oBAAA,IAAI,iBAAiB,CAAC,eAAe,CAAC,EAAE;AACtC,wBAAA,QAAQ,CAAC,eAAe,GAAG,eAAe,CAAA;AAC3C,qBAAA;AACF,iBAAA;AACF,aAAA;AACF,SAAA;AAED,QAAA,OAAO,QAAQ,CAAA;AAChB,KAAA;AAED,IAAA,OAAO,SAAS,CAAA;AAClB,CAAC;AAEM,MAAM,mCAAmC,GAAG,CACjD,EAAE,WAAW,EAAkB,EAC/B,mBAAiD,KACjB;;IAChC,IAAI,WAAW,KAAK,SAAS,EAAE;AAC7B,QAAA,MAAM,mBAAmB,GAAG,+BAA+B,CAAC,WAAW,CAAC,CAAA;QACxE,IAAI,mBAAmB,KAAK,SAAS;AAAE,YAAA,OAAO,mBAAmB,CAAA;;AAIjE,QAAA,MAAM,iBAAiB,GAAG,CAAA,EAAA,GAAAA,8BAAqB,CAAC,WAAW,EAAE,gCAAgC,CAAC,MAAA,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,EAAA,GAAIA,8BAAqB,CAAC,WAAW,EAAE,iCAAiC,CAAC,CAAA;AACvK,QAAA,MAAM,YAAY,GAAG,WAAW,CAAC,iBAAiB,CAAC,GAAG,iBAAiB,GAAG,mBAAmB,CAAC,YAAY,CAAA;AAE1G,QAAA,MAAM,aAAa,GAAG,CAAA,EAAA,GAAAA,8BAAqB,CAAC,WAAW,EAAE,2BAA2B,CAAC,MAAA,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,EAAA,GAAIA,8BAAqB,CAAC,WAAW,EAAE,4BAA4B,CAAC,CAAA;AACzJ,QAAA,MAAM,QAAQ,GAAG,sBAAsB,CAAC,aAAa,CAAC,GAAG,aAAa,GAAG,mBAAmB,CAAC,QAAQ,CAAA;AAErG,QAAA,MAAM,gBAAgB,GAAG,MAAM,CAC7B,CAAA,EAAA,GAAAA,8BAAqB,CAAC,WAAW,EAAE,+BAA+B,CAAC,MAAA,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,EAAA,GACnEA,8BAAqB,CAAC,WAAW,EAAE,gCAAgC,CAAC,CACrE,CAAA;AACD,QAAA,MAAM,WAAW,GAAG,iBAAiB,CAAC,gBAAgB,CAAC,GAAG,gBAAgB,GAAG,mBAAmB,CAAC,WAAW,CAAA;AAE5G,QAAA,MAAM,oBAAoB,GAAG,MAAM,CACjC,CAAA,EAAA,GAAAA,8BAAqB,CAAC,WAAW,EAAE,mCAAmC,CAAC,MAAA,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,EAAA,GACvEA,8BAAqB,CAAC,WAAW,EAAE,oCAAoC,CAAC,CACzE,CAAA;AACD,QAAA,MAAM,eAAe,GAAG,iBAAiB,CAAC,oBAAoB,CAAC,GAAG,oBAAoB,GAAG,mBAAmB,CAAC,eAAe,CAAA;AAE5H,QAAA,MAAM,SAAS,GAAG,CAAA,EAAA,GAAAA,8BAAqB,CAAC,WAAW,EAAE,sBAAsB,CAAC,MAAA,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,EAAA,GAAIA,8BAAqB,CAAC,WAAW,EAAE,uBAAuB,CAAC,CAAA;AAC3I,QAAA,MAAM,IAAI,GAAG,WAAW,CAAC,SAAS,CAAC,GAAG,SAAS,GAAG,mBAAmB,CAAC,IAAI,CAAA;QAE1E,OAAY,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,EAAA,EAAA,mBAAmB,CAAE,EAAA,EAAA,YAAY,EAAE,QAAQ,EAAE,WAAW,EAAE,eAAe,EAAE,IAAI,EAAE,CAAA,CAAA;AAC9F,KAAA;AAAM,SAAA;AACL,QAAA,OAAO,mBAAmB,CAAA;AAC3B,KAAA;AACH,CAAC,CAAA;AAED,SAAS,iCAAiC,CAAE,QAAsC,EAAA;AAChF,IAAA,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,GAAG,QAAQ,GAAG,EAAE,CAAA;AAC9C,IAAA,MAAM,cAAc,GAAG,CAAA,YAAA,EAAe,QAAQ,CAAC,UAAU,IAAI,CAAA;AAC7D,IAAA,MAAM,OAAO,GAAG,CAAA,IAAA,EAAO,QAAQ,CAAC,QAAQ,IAAI,CAAA;IAC5C,MAAM,YAAY,GAAG,QAAQ,CAAC,QAAQ,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,GAAG,CAAA,SAAA,EAAY,QAAQ,CAAC,QAAQ,CAAA,EAAA,CAAI,GAAG,EAAE,CAAA;AAC/G,IAAA,MAAM,kBAAkB,GAAG,QAAQ,CAAC,YAAY,GAAG,IAAI,GAAG,EAAE,CAAA;AAC5D,IAAA,MAAM,SAAS,GAAG,CAAA,EAAG,kBAAkB,CAAA,EAAG,QAAQ,CAAC,WAAW,CAAI,CAAA,EAAA,QAAQ,CAAC,eAAe,CAAA,EAAG,QAAQ,CAAC,SAAS,EAAE,CAAA;IACjH,OAAO,QAAQ,GAAG,cAAc,GAAG,OAAO,GAAG,YAAY,GAAG,SAAS,CAAA;AACvE,CAAC;AAED,SAAS,uBAAuB,CAAE,MAAc,EAAE,MAAc,EAAE,SAAiB,EAAA;;AAEjF,IAAA,KAAK,IAAI,CAAC,GAAG,SAAS,EAAE,CAAC,GAAG,MAAM,CAAC,QAAQ,EAAE,EAAE,CAAC,EAAE,EAAE;QAClD,MAAM,UAAU,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;AACpC,QAAA,IAAI,UAAU,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE;AACjC,YAAA,OAAO,CAAC,CAAA;AACT,SAAA;AACF,KAAA;AACD,IAAA,OAAO,SAAS,CAAA;AAClB,CAAC;AAEM,MAAM,yBAAyB,GAAG,CACvC,EAAE,WAAW,EAAkB,EAC/B,MAAc,EACd,QAAsC,KAC9B;IACR,IAAI,WAAW,KAAK,SAAS,EAAE;;QAG7B,MAAM,eAAe,GAAG,WAAW,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAA;AACvD,QAAA,MAAM,CAAC,GAAG,iCAAiC,CAAC,QAAQ,CAAC,CAAA;AACrD,QAAA,MAAM,oBAAoB,GAAG,CAAoB,iBAAA,EAAA,CAAC,IAAI,CAAA;AAEtD,QAAA,IAAI,WAAW,CAAC,iBAAiB,CAAC,KAAK,SAAS,EAAE;;YAEhD,MAAM,OAAO,GAAG,uBAAuB,CAAC,MAAM,EAAE,iBAAiB,EAAE,eAAe,CAAC,CAAA;YACnF,IAAI,OAAO,KAAK,SAAS;AAAE,gBAAA,MAAM,IAAI,KAAK,CAAC,qEAAqE,CAAC,CAAA;YACjH,MAAM,IAAI,GAAmB,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,EAAE,CAAA;AACrD,YAAA,MAAM,EAAE,GAAmB,EAAE,IAAI,EAAE,OAAO,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAA;YACvD,MAAM,CAAC,YAAY,CAAC,oBAAoB,EAAE,IAAI,EAAE,EAAE,CAAC,CAAA;AACpD,SAAA;AAAM,aAAA;;AAEL,YAAA,MAAM,IAAI,GAAmB,EAAE,IAAI,EAAE,eAAe,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAA;AACjE,YAAA,MAAM,EAAE,GAAmB,EAAE,IAAI,EAAE,eAAe,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAA;YAC/D,MAAM,CAAC,YAAY,CAAC,oBAAoB,EAAE,IAAI,EAAE,EAAE,CAAC,CAAA;AACpD,SAAA;AACF,KAAA;AAAM,SAAA;;AAEL,QAAA,MAAM,CAAC,GAAG,iCAAiC,CAAC,QAAQ,CAAC,CAAA;AACrD,QAAA,MAAM,cAAc,GAAG,CAAyB,sBAAA,EAAA,CAAC,WAAW,CAAA;QAC5D,MAAM,IAAI,GAAmB,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAA;QAC/C,MAAM,EAAE,GAAmB,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAA;QAC7C,MAAM,CAAC,YAAY,CAAC,cAAc,EAAE,IAAI,EAAE,EAAE,CAAC,CAAA;;AAE9C,KAAA;AACH,CAAC;;AC/JD,MAAM,kBAAmB,SAAQC,cAAK,CAAA;IAGpC,WAAa,CAAA,GAAQ,EAAE,MAA2B,EAAA;QAChD,KAAK,CAAC,GAAG,CAAC,CAAA;AACV,QAAA,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;KACrB;IAED,MAAM,GAAA;AACJ,QAAA,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,GAAG,IAAI,CAAA;AACnC,QAAA,OAAO,CAAC,OAAO,CAAC,0CAA0C,CAAC,CAAA;AAE3D,QAAA,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,CAAA;AACxD,QAAA,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,mBAAmB,EAAE,CAAC,CAAA;AAEpE,QAAA,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,oEAAoE,EAAE,GAAG,EAAE,0BAA0B,EAAE,CAAC,CAAA;AAE1I,QAAA,MAAM,mBAAmB,GAAG,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,GAAG,EAAE,kCAAkC,EAAE,CAAC,CAAA;QAElG,MAAM,QAAQ,GAAG,mBAAmB,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAG,CAAC,CAAA;AAC5D,QAAA,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;AACtB,QAAA,QAAQ,CAAC,YAAY,CAAC,CAAC,EAAc,KAAI;YACvC,IAAI,CAAC,KAAK,EAAE,CAAA;AACZ,YAAA,OAAO,EAAE,CAAA;AACX,SAAC,CAAC,CAAA;QAEF,MAAM,SAAS,GAAG,mBAAmB,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAG,CAAC,CAAA;AAC7D,QAAA,SAAS,CAAC,OAAO,CAAC,gCAAgC,CAAC,CAAA;AACnD,QAAA,SAAS,CAAC,YAAY,CAAC,CAAC,EAAc,KAAI;AACxC,YAAA,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAA;YACvC,IAAI,CAAC,KAAK,EAAE,CAAA;AACZ,YAAA,OAAO,EAAE,CAAA;AACX,SAAC,CAAC,CAAA;QAEF,MAAM,gBAAgB,GAAG,mBAAmB,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAG,CAAC,CAAA;AACpE,QAAA,gBAAgB,CAAC,OAAO,CAAC,0DAA0D,CAAC,CAAA;AACpF,QAAA,gBAAgB,CAAC,YAAY,CAAC,CAAC,EAAc,KAAI;AAC/C,YAAA,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAA;YACtC,IAAI,CAAC,KAAK,EAAE,CAAA;AACZ,YAAA,OAAO,EAAE,CAAA;AACX,SAAC,CAAC,CAAA;KACH;IAED,OAAO,GAAA;AACL,QAAA,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,GAAG,IAAI,CAAA;QACnC,SAAS,CAAC,KAAK,EAAE,CAAA;QACjB,OAAO,CAAC,KAAK,EAAE,CAAA;KAChB;AACF,CAAA;SAEe,wBAAwB,CAAE,GAAQ,EAAE,QAAsC,EAAE,QAAkB,EAAA;AAC5G,IAAA,MAAM,oBAAoB,GAAG,CAAC,iBAA0B,KAAU;AAChE,QAAA,MAAM,eAAe,GAAA,MAAA,CAAA,MAAA,CAAA,EAAA,EAAQ,QAAQ,CAAE,CAAA;AACvC,QAAA,IAAI,iBAAiB;AAAE,YAAA,eAAe,CAAC,IAAI,GAAG,IAAI,CAAA;QAClD,yBAAyB,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;AAC5E,KAAC,CAAA;AACD,IAAA,MAAM,MAAM,GAAwB;AAClC,QAAA,OAAO,EAAE,CAAA;;AAEe,2BAAA,CAAA;AACxB,QAAA,mBAAmB,EAAE,CAAA,0BAAA,EAA6B,QAAQ,CAAC,YAAY,CAAA;AACpD,qBAAA,EAAA,QAAQ,CAAC,UAAU,CAAA;AACjB,uBAAA,EAAA,QAAQ,CAAC,QAAQ,CAAA;AACZ,4BAAA,EAAA,QAAQ,CAAC,WAAW,CAAA;AACA,gDAAA,EAAA,QAAQ,CAAC,eAAe,CAAA;AAC7D,WAAA,EAAA,QAAQ,CAAC,SAAS,CAAA;4BACH,QAAQ,CAAC,QAAQ,CAAE,CAAA;QAC3C,oBAAoB;KACrB,CAAA;AAED,IAAA,MAAM,IAAI,GAAG,GAAG,CAAC,SAAS,CAAC,UAAU,CAAA;AACrC,IAAA,IAAI,IAAI,EAAE;QACR,IAAI,kBAAkB,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,IAAI,EAAE,CAAA;AAC3C,KAAA;AACH;;ACjFA,MAAM,oBAAoB,GAAG,GAAG,CAAA;AAEhC,SAAS,qBAAqB,CAAE,MAAc,EAAE,OAAqB,EAAA;IACnE,MAAM,KAAK,GAAG,aAAa,CAAA;AAC3B,IAAA,MAAM,iBAAiB,GAAG,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;AACrE,IAAA,IAAI,CAAC,iBAAiB;AAAE,QAAA,OAAO,SAAS,CAAA;IAExC,MAAM,OAAO,GAAG,iBAAiB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;AAC9C,IAAA,IAAI,CAAC,OAAO;AAAE,QAAA,OAAO,SAAS,CAAA;AAE9B,IAAA,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;;QAExB,OAAO,CAAC,GAAG,CAAC,8BAA8B,GAAG,iBAAiB,GAAG,GAAG,CAAC,CAAA;AACrE,QAAA,OAAO,SAAS,CAAA;AACjB,KAAA;AAED,IAAA,MAAM,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;AACxB,IAAA,OAAO,KAAK,CAAC,QAAQ,EAAE,CAAA;AACzB,CAAC;AAED,SAAS,mBAAmB,CAAE,cAAgC,EAAA;IAC5D,IAAI,eAAe,GAAG,EAAE,CAAA;AAExB,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,cAAc,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QAC9C,IAAI,CAAC,KAAK,CAAC,EAAE;YACX,eAAe,IAAI,GAAG,CAAA;AACvB,SAAA;AAAM,aAAA;YACL,eAAe,IAAI,GAAG,CAAA;AACvB,SAAA;QACD,eAAe,IAAI,cAAc,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAA;AAChD,KAAA;AAED,IAAA,OAAO,eAAe,CAAA;AACxB,CAAC;AAED,SAAS,qBAAqB,CAAE,MAAc,EAAE,OAAqB,EAAA;IACnE,MAAM,KAAK,GAAG,6DAA6D,CAAA;AAC3E,IAAA,MAAM,iBAAiB,GAAG,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;AACrE,IAAA,IAAI,CAAC,iBAAiB;AAAE,QAAA,OAAO,SAAS,CAAA;IAExC,MAAM,OAAO,GAAG,iBAAiB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;AAE9C,IAAA,IAAI,OAAO,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;;QAEnC,OAAO,CAAC,GAAG,CAAC,8BAA8B,GAAG,iBAAiB,GAAG,GAAG,CAAC,CAAA;AACrE,QAAA,OAAO,SAAS,CAAA;AACjB,KAAA;AAED,IAAA,MAAM,KAAK,GAAG,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,CAAA;AAEvC,IAAA,MAAM,IAAI,GAAG;AACX,QAAA,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI;AACjC,QAAA,EAAE,EAAE,CAAC;KACN,CAAA;AACD,IAAA,MAAM,EAAE,GAAG;AACT,QAAA,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI;QACjC,EAAE,EAAE,KAAK,CAAC,MAAM;KACjB,CAAA;AAED,IAAA,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,CAAA;AACrB,CAAC;AAID,SAAS,2BAA2B,CAAE,KAAa,EAAA;IACjD,IAAI,KAAK,KAAK,GAAG,EAAE;AACjB,QAAA,OAAO,CAAC,CAAA;AACT,KAAA;SAAM,IAAI,KAAK,KAAK,GAAG,EAAE;AACxB,QAAA,OAAO,GAAG,CAAA;AACX,KAAA;AAED,IAAA,OAAO,CAAC,CAAA;AACV,CAAC;AAED,SAAS,0BAA0B,CAAE,KAAa,EAAA;IAChD,IAAI,KAAK,KAAK,GAAG,EAAE;AACjB,QAAA,OAAO,CAAC,CAAA;AACT,KAAA;SAAM,IAAI,KAAK,KAAK,GAAG,EAAE;AACxB,QAAA,OAAO,GAAG,CAAA;AACX,KAAA;AAED,IAAA,OAAO,CAAC,CAAA;AACV,CAAC;AAED,SAAS,kBAAkB,CAAE,CAAiB,EAAA;AAC5C,IAAA,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE;QACzB,OAAO,CAAC,GAAG,CAAC,CAAA;AACb,KAAA;AAED,IAAA,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE;QACzB,IAAI,CAAC,KAAK,GAAG;AAAE,YAAA,OAAO,GAAG,CAAA;;AACpB,YAAA,OAAO,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAA;AACrD,KAAA;AAED,IAAA,OAAO,CAAC,CAAA;AACV,CAAC;AAED,SAAS,sBAAsB,CAAE,KAAa,EAAA;AAC5C,IAAA,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;QACvB,MAAM,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;AAC1B,QAAA,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE;AAChB,YAAA,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAA;AACnB,SAAA;AACF,KAAA;AACD,IAAA,OAAO,KAAK,CAAC,IAAI,EAAE,CAAA;AACrB,CAAC;AAED;AACA,SAAS,cAAc,CAAE,CAAe,EAAE,QAAsC,EAAE,mBAA2B,EAAA;AAC3G,IAAA,MAAM,IAAI,GAAG,CAAC,CAAC,OAAO,CAAA;AACtB,IAAA,MAAM,SAAS,GAAG,sBAAsB,CAAC,IAAI,CAAC,CAAA;IAE9C,IAAI,YAAY,GAAG,EAAE,CAAA;IACrB,MAAM,UAAU,GAAG,mBAAmB,CAAA;AACtC,IAAA,KAAK,IAAI,CAAC,GAAG,UAAU,EAAE,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;QACzC,YAAY,IAAI,IAAI,CAAA;AACrB,KAAA;AAED,IAAA,MAAM,SAAS,GAAG,CAAA,GAAA,EAAM,IAAI,CAAI,CAAA,EAAA,SAAS,IAAI,CAAA;AAE7C,IAAA,OAAO,YAAY,GAAG,oBAAoB,GAAG,GAAG,GAAG,SAAS,CAAA;AAC9D,CAAC;AAED;AACA,SAAS,kBAAkB,CAAE,MAAc,EAAE,OAAuB,EAAE,KAAkB,EAAE,IAAY,EAAA;AACpG,IAAA,MAAM,YAAY,GAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC,CAAA;IAE1D,IAAI,YAAY,KAAK,IAAI,EAAE;QACzB,OAAO,CAAC,IAAI,CAAC;AACX,YAAA,IAAI,EAAE,IAAI;YACV,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,EAAE,EAAE,KAAK,CAAC,EAAE;AACb,SAAA,CAAC,CAAA;AACH,KAAA;AACH,CAAC;AAEM,MAAM,sBAAsB,GAAG,CACpC,QAA8B,EAC9B,QAAsC,KAC9B;;AACR,IAAA,IAAI,CAAC,QAAQ;QAAE,OAAM;IACrB,MAAM,QAAQ,GAAG,CAAA,EAAA,GAAA,QAAQ,CAAC,IAAI,CAAC,QAAQ,MAAI,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,EAAA,GAAA,EAAE,CAAA;AAC7C,IAAA,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAA;IAE9B,IAAI,aAAa,GAAG,CAAC,CAAA;IAErB,IAAI,cAAc,GAAqB,CAAC,2BAA2B,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAA;AAE1F,IAAA,IAAI,QAAQ,CAAC,UAAU,GAAG,CAAC,EAAE;AAC3B,QAAA,aAAa,GAAG,QAAQ,CAAC,UAAU,CAAA;AACpC,KAAA;SAAM,IAAI,QAAQ,CAAC,YAAY,EAAE;QAChC,aAAa,GAAG,CAAC,CAAA;AAClB,KAAA;IAED,MAAM,OAAO,GAAmB,EAAE,CAAA;AAElC,IAAA,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE;;AAG9B,QAAA,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAA;;AAG3B,QAAA,IAAI,CAAC,QAAQ,CAAC,UAAU,GAAG,KAAK,MAAM,QAAQ,CAAC,YAAY,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE;;;;YAK3E,cAAc,GAAG,CAAC,2BAA2B,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAA;AAEpE,YAAA,IAAI,QAAQ,CAAC,UAAU,GAAG,CAAC,EAAE;AAC3B,gBAAA,aAAa,GAAG,QAAQ,CAAC,UAAU,CAAA;AACpC,aAAA;iBAAM,IAAI,QAAQ,CAAC,YAAY,EAAE;gBAChC,aAAa,GAAG,CAAC,CAAA;AAClB,aAAA;YACD,SAAQ;AACT,SAAA;;QAGD,IAAI,KAAK,KAAK,aAAa,EAAE;AAC3B,YAAA,MAAM,CAAC,GAAG,cAAc,CAAC,GAAG,EAAE,CAAA;YAC9B,IAAI,CAAC,KAAK,SAAS,EAAE;gBACnB,cAAc,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAA;AAC3C,aAAA;AACF,SAAA;aAAM,IAAI,KAAK,GAAG,aAAa,EAAE;YAChC,KAAK,IAAI,CAAC,GAAG,aAAa,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE;gBAC1C,cAAc,CAAC,GAAG,EAAE,CAAA;AACrB,aAAA;AACD,YAAA,MAAM,CAAC,GAAG,cAAc,CAAC,GAAG,EAAE,CAAA;YAC9B,IAAI,CAAC,KAAK,SAAS,EAAE;gBACnB,cAAc,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAA;AAC3C,aAAA;AACF,SAAA;aAAM,IAAI,KAAK,GAAG,aAAa,EAAE;YAChC,KAAK,IAAI,CAAC,GAAG,aAAa,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE;gBAC1C,cAAc,CAAC,IAAI,CAAC,0BAA0B,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAA;AAC1E,aAAA;AACF,SAAA;;QAGD,aAAa,GAAG,KAAK,CAAA;AAErB,QAAA,IAAI,KAAK,GAAG,QAAQ,CAAC,QAAQ,EAAE;;YAE7B,SAAQ;AACT,SAAA;;QAGD,MAAM,WAAW,GAAG,qBAAqB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAC1D,IAAI,WAAW,KAAK,SAAS;YAAE,OAAM;QACrC,MAAM,iBAAiB,GAAG,qBAAqB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAChE,IAAI,iBAAiB,KAAK,SAAS;YAAE,OAAM;AAC3C,QAAA,MAAM,YAAY,GAAG,mBAAmB,CAAC,cAAc,CAAC,CAAA;AACxD,QAAA,kBAAkB,CAAC,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,iBAAiB,GAAG,YAAY,GAAG,QAAQ,CAAC,SAAS,GAAG,GAAG,CAAC,CAAA;AAC9G,KAAA;;AAGD,IAAA,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;;QAEtB,OAAO,CAAC,GAAG,CAAC,8DAA8D,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;QAC3F,MAAM,CAAC,WAAW,CAAC;AACjB,YAAA,OAAO,EAAE,OAAO;AACjB,SAAA,CAAC,CAAA;AACH,KAAA;AACH,CAAC,CAAA;AAEM,MAAM,qBAAqB,GAAG,CACnC,QAA8B,EAC9B,QAAsC,KAC9B;;AACR,IAAA,IAAI,CAAC,QAAQ;QAAE,OAAM;IACrB,MAAM,QAAQ,GAAG,CAAA,EAAA,GAAA,QAAQ,CAAC,IAAI,CAAC,QAAQ,MAAI,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,EAAA,GAAA,EAAE,CAAA;AAC7C,IAAA,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAA;AAE9B,IAAA,IAAI,CAAC,qBAAqB,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAAE,OAAM;AAErD,IAAA,IAAI,UAAoC,CAAA;IACxC,IAAI,UAAU,GAAG,IAAI,CAAA;IACrB,MAAM,OAAO,GAAmB,EAAE,CAAA;;IAGlC,IAAI,mBAAmB,GAAG,CAAC,CAAA;AAC3B,IAAA,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE;AACvB,QAAA,mBAAmB,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,CAAA;AACxC,KAAA;AAED,IAAA,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE;;;QAI9B,IAAI,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE;YAC/C,UAAU,GAAG,OAAO,CAAA;AACrB,SAAA;AAED;;;;AAIE;QAEF,MAAM,QAAQ,GAAG,cAAc,CAAC,OAAO,EAAE,QAAQ,EAAE,mBAAmB,CAAC,CAAA;AACvE,QAAA,UAAU,IAAI,QAAQ,GAAG,IAAI,CAAA;AAC9B,KAAA;;AAGD,IAAA,IAAI,UAAU,EAAE;AACd,QAAA,MAAM,IAAI,GAAG;YACX,IAAI,EAAE,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC;AACxC,YAAA,EAAE,EAAE,CAAC;SACN,CAAA;QAED,MAAM,YAAY,GAAG,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,CAAA;QACvD,IAAI,UAAU,GAAG,CAAC,CAAA;QAClB,IAAI,SAAS,GAAG,KAAK,CAAA;AACrB,QAAA,KAAK,UAAU,GAAG,YAAY,GAAI,UAAU,EAAE,EAAE;YAC9C,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,CAAA;YACvC,IAAI,IAAI,KAAK,SAAS,EAAE;;gBAEtB,UAAU,GAAG,YAAY,CAAA;gBACzB,MAAK;AACN,aAAA;AACD,YAAA,MAAM,eAAe,GAAG,IAAI,CAAC,SAAS,EAAE,CAAA;AACxC,YAAA,IAAI,SAAS,EAAE;AACb,gBAAA,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,oBAAoB,CAAC;oBAAE,MAAK;AAC5D,gBAAA,IAAI,eAAe,CAAC,UAAU,CAAC,GAAG,CAAC;oBAAE,MAAK;AAC3C,aAAA;AAAM,iBAAA;AACL,gBAAA,IAAI,eAAe,CAAC,UAAU,CAAC,oBAAoB,CAAC,EAAE;oBACpD,SAAS,GAAG,IAAI,CAAA;AACjB,iBAAA;AAAM,qBAAA,IAAI,eAAe,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;;oBAE1C,UAAU,GAAG,YAAY,CAAA;oBACzB,MAAK;AACN,iBAAA;AAAM,qBAAA;oBACL,SAAQ;AACT,iBAAA;AACF,aAAA;AACF,SAAA;QAED,IAAI,UAAU,KAAK,IAAI,EAAE;YACvB,UAAU,GAAG,EAAE,CAAA;AAChB,SAAA;AAED,QAAA,MAAM,EAAE,GAAG;AACT,YAAA,IAAI,EAAE,UAAU;AAChB,YAAA,EAAE,EAAE,CAAC;SACN,CAAA;AACD,QAAA,MAAM,KAAK,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,CAAA;QAC1B,kBAAkB,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,CAAC,CAAA;AACvD,KAAA;;AAGD,IAAA,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;;QAEtB,OAAO,CAAC,GAAG,CAAC,6DAA6D,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;QAC1F,MAAM,CAAC,WAAW,CAAC;AACjB,YAAA,OAAO,EAAE,OAAO;AACjB,SAAA,CAAC,CAAA;AACH,KAAA;AACH,CAAC,CAAA;AAEM,MAAM,sBAAsB,GAAG,CACpC,QAA8B,KACtB;;AACR,IAAA,IAAI,CAAC,QAAQ;QAAE,OAAM;IACrB,MAAM,QAAQ,GAAG,CAAA,EAAA,GAAA,QAAQ,CAAC,IAAI,CAAC,QAAQ,MAAI,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,EAAA,GAAA,EAAE,CAAA;AAC7C,IAAA,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAA;IAE9B,MAAM,OAAO,GAAmB,EAAE,CAAA;AAElC,IAAA,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE;QAC9B,MAAM,WAAW,GAAG,qBAAqB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAC1D,IAAI,WAAW,KAAK,SAAS;YAAE,OAAM;QACrC,MAAM,iBAAiB,GAAG,qBAAqB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAChE,IAAI,iBAAiB,KAAK,SAAS;YAAE,OAAM;QAC3C,kBAAkB,CAAC,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,iBAAiB,GAAG,GAAG,CAAC,CAAA;AAC1E,KAAA;AAED,IAAA,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;QACtB,MAAM,CAAC,WAAW,CAAC;AACjB,YAAA,OAAO,EAAE,OAAO;AACjB,SAAA,CAAC,CAAA;AACH,KAAA;AACH,CAAC;;ACjVD,MAAM,8BAA+B,SAAQC,yBAAgB,CAAA;IAG3D,WAAa,CAAA,GAAQ,EAAE,MAA4B,EAAA;AACjD,QAAA,KAAK,CAAC,GAAG,EAAE,MAAM,CAAC,CAAA;AAClB,QAAA,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;KACrB;IAED,OAAO,GAAA;AACL,QAAA,MAAM,EAAE,WAAW,EAAE,GAAG,IAAI,CAAA;QAE5B,WAAW,CAAC,KAAK,EAAE,CAAA;QAEnB,WAAW,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,4BAA4B,EAAE,CAAC,CAAA;QAElE,WAAW,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,2JAA2J,EAAE,CAAC,CAAA;AAElM,QAAA,WAAW,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,CAAA;QAE9B,WAAW,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,4KAA4K,EAAE,CAAC,CAAA;AAEnN,QAAA,WAAW,CAAC,QAAQ,CAAC,KAAK,EAAE;AAC1B,YAAA,IAAI,EAAE,CAAA;;;;;;AAMJ,OAAA,CAAA;AACH,SAAA,CAAC,CAAA;AAEF,QAAA,WAAW,CAAC,QAAQ,CAAC,KAAK,EAAE;AAC1B,YAAA,IAAI,EAAE,CAAA;;;AAGP,IAAA,CAAA;AACA,SAAA,CAAC,CAAA;QAEF,MAAM,EAAE,GAAG,WAAW,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,CAAA;QAEzC,MAAM,GAAG,GAAG,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAG,CAAC,CAAA;QAClC,GAAG,CAAC,QAAQ,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,qBAAqB,EAAE,CAAC,CAAA;QAClD,GAAG,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,qEAAqE,EAAE,CAAC,CAAA;QAErG,MAAM,GAAG,GAAG,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAG,CAAC,CAAA;QAClC,GAAG,CAAC,QAAQ,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,uBAAuB,EAAE,CAAC,CAAA;QACpD,GAAG,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,8EAA8E,EAAE,CAAC,CAAA;QAE9G,MAAM,GAAG,GAAG,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAG,CAAC,CAAA;QAClC,GAAG,CAAC,QAAQ,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,yBAAyB,EAAE,CAAC,CAAA;QACtD,GAAG,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,qEAAqE,EAAE,CAAC,CAAA;QAErG,MAAM,GAAG,GAAG,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAG,CAAC,CAAA;QAClC,GAAG,CAAC,QAAQ,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,0BAA0B,EAAE,CAAC,CAAA;QACvD,GAAG,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,+HAA+H,EAAE,CAAC,CAAA;QAE/J,MAAM,GAAG,GAAG,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAG,CAAC,CAAA;QAClC,GAAG,CAAC,QAAQ,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC,CAAA;AAC9C,QAAA,GAAG,CAAC,QAAQ,CAAC,MAAM,EAAE;AACnB,YAAA,IAAI,EAAE,CAAA;;;AAGY,uBAAA,CAAA;AACnB,SAAA,CAAC,CAAA;QAEF,MAAM,GAAG,GAAG,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,CAAA;AAClC,QAAA,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE;AACjB,YAAA,IAAI,EAAE,CAAA;;AAEP,IAAA,CAAA;AACA,SAAA,CAAC,CAAA;AACF,QAAA,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE;AACjB,YAAA,IAAI,EAAE,CAAA;;AAEP,IAAA,CAAA;AACA,SAAA,CAAC,CAAA;AACF,QAAA,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE;AACjB,YAAA,IAAI,EAAE,CAAA;;AAEP,IAAA,CAAA;AACA,SAAA,CAAC,CAAA;AACF,QAAA,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE;AACjB,YAAA,IAAI,EAAE,CAAA;;AAEP,IAAA,CAAA;AACA,SAAA,CAAC,CAAA;AACF,QAAA,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE;AACjB,YAAA,IAAI,EAAE,CAAA;;AAEP,IAAA,CAAA;AACA,SAAA,CAAC,CAAA;QAEF,IAAIC,gBAAO,CAAC,WAAW,CAAC;aACrB,OAAO,CAAC,wBAAwB,CAAC;aACjC,OAAO,CAAC,sEAAsE,CAAC;AAC/E,aAAA,SAAS,CAAC,MAAM,IAAI,MAAM;aACxB,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAC;aAC3C,UAAU,CAAC,wBAAwB,CAAC;AACpC,aAAA,QAAQ,CAAC,CAAO,KAAK,KAAI,SAAA,CAAA,IAAA,EAAA,KAAA,CAAA,EAAA,KAAA,CAAA,EAAA,aAAA;YACxB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,GAAG,KAAK,CAAA;AACzC,YAAA,MAAM,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAA;SACjC,CAAA,CAAC,CAAC,CAAA;QAEP,IAAIA,gBAAO,CAAC,WAAW,CAAC;aACrB,OAAO,CAAC,qBAAqB,CAAC;aAC9B,OAAO,CAAC,gCAAgC,CAAC;AACzC,aAAA,SAAS,CAAC,MAAM,IAAI,MAAM;AACxB,aAAA,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;aAClB,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC;AACzC,aAAA,iBAAiB,EAAE;AACnB,aAAA,QAAQ,CAAC,CAAO,KAAK,KAAI,SAAA,CAAA,IAAA,EAAA,KAAA,CAAA,EAAA,KAAA,CAAA,EAAA,aAAA;YACxB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,GAAG,KAAK,CAAA;AACvC,YAAA,MAAM,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAA;SACjC,CAAA,CAAC,CAAC,CAAA;QAEP,IAAIA,gBAAO,CAAC,WAAW,CAAC;aACrB,OAAO,CAAC,uBAAuB,CAAC;aAChC,OAAO,CAAC,kCAAkC,CAAC;AAC3C,aAAA,SAAS,CAAC,MAAM,IAAI,MAAM;AACxB,aAAA,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;aAClB,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC;AACvC,aAAA,iBAAiB,EAAE;AACnB,aAAA,QAAQ,CAAC,CAAO,KAAK,KAAI,SAAA,CAAA,IAAA,EAAA,KAAA,CAAA,EAAA,KAAA,CAAA,EAAA,aAAA;YACxB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,GAAG,KAAK,CAAA;AACrC,YAAA,MAAM,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAA;SACjC,CAAA,CAAC,CAAC,CAAA;QAEP,IAAIA,gBAAO,CAAC,WAAW,CAAC;aACrB,OAAO,CAAC,4BAA4B,CAAC;aACrC,OAAO,CAAC,kHAAkH,CAAC;AAC3H,aAAA,OAAO,CAAC,IAAI,IAAI,IAAI;aAClB,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC;AAC1C,aAAA,QAAQ,CAAC,CAAO,KAAK,KAAI,SAAA,CAAA,IAAA,EAAA,KAAA,CAAA,EAAA,KAAA,CAAA,EAAA,aAAA;YACxB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,GAAG,KAAK,CAAA;AACxC,YAAA,MAAM,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAA;SACjC,CAAA,CAAC,CAAC,CAAA;QAEP,IAAIA,gBAAO,CAAC,WAAW,CAAC;aACrB,OAAO,CAAC,gDAAgD,CAAC;aACzD,OAAO,CAAC,wHAAwH,CAAC;AACjI,aAAA,OAAO,CAAC,IAAI,IAAI,IAAI;aAClB,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAC;AAC9C,aAAA,QAAQ,CAAC,CAAO,KAAK,KAAI,SAAA,CAAA,IAAA,EAAA,KAAA,CAAA,EAAA,KAAA,CAAA,EAAA,aAAA;YACxB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,GAAG,KAAK,CAAA;AAC5C,YAAA,MAAM,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAA;SACjC,CAAA,CAAC,CAAC,CAAA;QAEP,IAAIA,gBAAO,CAAC,WAAW,CAAC;aACrB,OAAO,CAAC,qBAAqB,CAAC;aAC9B,OAAO,CAAC,4CAA4C,CAAC;AACrD,aAAA,SAAS,CAAC,MAAM,IAAI,MAAM;aACxB,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC;aACnC,UAAU,CAAC,6BAA6B,CAAC;AACzC,aAAA,QAAQ,CAAC,CAAO,KAAK,KAAI,SAAA,CAAA,IAAA,EAAA,KAAA,CAAA,EAAA,KAAA,CAAA,EAAA,aAAA;YACxB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,GAAG,KAAK,CAAA;AACjC,YAAA,MAAM,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAA;SACjC,CAAA,CAAC,CAAC,CAAA;QAEP,IAAIA,gBAAO,CAAC,WAAW,CAAC;aACrB,OAAO,CAAC,iBAAiB,CAAC;aAC1B,OAAO,CAAC,+KAA+K,CAAC;AACxL,aAAA,OAAO,CAAC,IAAI,IAAI,IAAI;aAClB,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC;AACxC,aAAA,QAAQ,CAAC,CAAO,KAAK,KAAI,SAAA,CAAA,IAAA,EAAA,KAAA,CAAA,EAAA,KAAA,CAAA,EAAA,aAAA;YACxB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,GAAG,KAAK,CAAA;AACtC,YAAA,MAAM,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAA;SACjC,CAAA,CAAC,CAAC,CAAA;QAEP,IAAIA,gBAAO,CAAC,WAAW,CAAC;aACrB,OAAO,CAAC,0BAA0B,CAAC;aACnC,OAAO,CAAC,oJAAoJ,CAAC;AAC7J,aAAA,OAAO,CAAC,IAAI,IAAI,IAAI;aAClB,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC;AACvC,aAAA,QAAQ,CAAC,CAAO,KAAK,KAAI,SAAA,CAAA,IAAA,EAAA,KAAA,CAAA,EAAA,KAAA,CAAA,EAAA,aAAA;YACxB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,GAAG,KAAK,CAAA;AACrC,YAAA,MAAM,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAA;SACjC,CAAA,CAAC,CAAC,CAAA;KACR;AACF,CAAA;AAEoB,MAAA,oBAAqB,SAAQC,eAAM,CAAA;IAGhD,MAAM,GAAA;;;YAEV,OAAO,CAAC,IAAI,CAAC,0CAA0C,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAA;AAEhF,YAAA,MAAM,IAAI,CAAC,YAAY,EAAE,CAAA;YAEzB,IAAI,CAAC,UAAU,CAAC;AACd,gBAAA,EAAE,EAAE,8BAA8B;AAClC,gBAAA,IAAI,EAAE,oDAAoD;AAC1D,gBAAA,aAAa,EAAE,CAAC,QAAiB,KAAI;AACnC,oBAAA,IAAI,QAAQ;AAAE,wBAAA,OAAO,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;oBAE3C,MAAM,QAAQ,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACtC,oBAAA,IAAI,QAAQ,EAAE;AACZ,wBAAA,MAAM,QAAQ,GAAG,mCAAmC,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;AAClF,wBAAA,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;wBAC1C,UAAU,CAAC,MAAK;;4BAEd,MAAM,qBAAqB,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACnD,4BAAA,qBAAqB,CAAC,qBAAqB,EAAE,QAAQ,CAAC,CAAA;yBACvD,EAAE,IAAI,CAAC,CAAA;wBAER,wBAAwB,CAAC,IAAI,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAA;AACvD,qBAAA;AAED,oBAAA,OAAO,KAAK,CAAA;iBACb;AACF,aAAA,CAAC,CAAA;YAEF,IAAI,CAAC,UAAU,CAAC;AACd,gBAAA,EAAE,EAAE,iBAAiB;AACrB,gBAAA,IAAI,EAAE,iCAAiC;AACvC,gBAAA,aAAa,EAAE,CAAC,QAAiB,KAAI;AACnC,oBAAA,IAAI,QAAQ;AAAE,wBAAA,OAAO,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;oBAE3C,MAAM,QAAQ,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACtC,oBAAA,IAAI,QAAQ,EAAE;AACZ,wBAAA,MAAM,QAAQ,GAAG,mCAAmC,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;AAClF,wBAAA,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;wBAC1C,UAAU,CAAC,MAAK;;4BAEd,MAAM,qBAAqB,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACnD,4BAAA,qBAAqB,CAAC,qBAAqB,EAAE,QAAQ,CAAC,CAAA;yBACvD,EAAE,IAAI,CAAC,CAAA;;;;AAKT,qBAAA;AAED,oBAAA,OAAO,KAAK,CAAA;iBACb;AACF,aAAA,CAAC,CAAA;YAEF,IAAI,CAAC,UAAU,CAAC;AACd,gBAAA,EAAE,EAAE,wBAAwB;AAC5B,gBAAA,IAAI,EAAE,gDAAgD;AACtD,gBAAA,aAAa,EAAE,CAAC,QAAiB,KAAI;AACnC,oBAAA,IAAI,QAAQ;AAAE,wBAAA,OAAO,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;oBAE3C,MAAM,QAAQ,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;oBACtC,sBAAsB,CAAC,QAAQ,CAAC,CAAA;AAEhC,oBAAA,OAAO,IAAI,CAAA;iBACZ;AACF,aAAA,CAAC,CAAA;YAEF,IAAI,CAAC,UAAU,CAAC;AACd,gBAAA,EAAE,EAAE,+BAA+B;AACnC,gBAAA,IAAI,EAAE,+BAA+B;AACrC,gBAAA,aAAa,EAAE,CAAC,QAAiB,KAAI;AACnC,oBAAA,IAAI,QAAQ;AAAE,wBAAA,OAAO,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;oBAE3C,MAAM,QAAQ,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACtC,oBAAA,IAAI,QAAQ,EAAE;AACZ,wBAAA,MAAM,QAAQ,GAAG,mCAAmC,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;wBAClF,yBAAyB,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;AACpE,qBAAA;AAED,oBAAA,OAAO,KAAK,CAAA;iBACb;AACF,aAAA,CAAC,CAAA;AAEF,YAAA,IAAI,CAAC,aAAa,CAAC,IAAI,8BAA8B,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAA;YAEtE,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,WAAW,CAAC,MAAK;gBAC5C,MAAM,QAAQ,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACtC,gBAAA,IAAI,QAAQ,EAAE;AACZ,oBAAA,MAAM,QAAQ,GAAG,mCAAmC,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;oBAElF,IAAI,QAAQ,CAAC,IAAI,EAAE;AACjB,wBAAA,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;wBAC1C,UAAU,CAAC,MAAK;;4BAEd,MAAM,qBAAqB,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACnD,4BAAA,qBAAqB,CAAC,qBAAqB,EAAE,QAAQ,CAAC,CAAA;yBACvD,EAAE,IAAI,CAAC,CAAA;;AAER,wBAAA,OAAO,CAAC,GAAG,CAAC,yDAAyD,CAAC,CAAA;AACvE,qBAAA;AACF,iBAAA;AACH,aAAC,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC,CAAA;SACf,CAAA,CAAA;AAAA,KAAA;IAEK,YAAY,GAAA;;AAChB,YAAA,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,EAAE,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAA;SAC3E,CAAA,CAAA;AAAA,KAAA;IAEK,YAAY,GAAA;;YAChB,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;SACnC,CAAA,CAAA;AAAA,KAAA;AACF;;;;"} diff --git a/.obsidian/plugins/number headings/manifest.json b/.obsidian/plugins/number headings/manifest.json new file mode 100644 index 0000000..69b1fe8 --- /dev/null +++ b/.obsidian/plugins/number headings/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "number-headings-obsidian", + "name": "Number Headings", + "version": "1.10.0", + "minAppVersion": "0.12.0", + "description": "Automatically number or re-number headings in an Obsidian document", + "author": "Kevin Albrecht (onlyafly@gmail.com)", + "authorUrl": "https://www.kevinalbrecht.com", + "isDesktopOnly": false +} \ No newline at end of file diff --git a/.obsidian/plugins/number headings/styles.css b/.obsidian/plugins/number headings/styles.css new file mode 100644 index 0000000..12a666b --- /dev/null +++ b/.obsidian/plugins/number headings/styles.css @@ -0,0 +1,8 @@ +div.number-headings-button-container > button { + font-weight: normal; +} + +div.number-headings-question { + font-weight: bold; + margin-bottom: 10px; +} \ No newline at end of file diff --git a/.obsidian/plugins/number-headings-obsidian/data.json b/.obsidian/plugins/number-headings-obsidian/data.json new file mode 100644 index 0000000..ad33379 --- /dev/null +++ b/.obsidian/plugins/number-headings-obsidian/data.json @@ -0,0 +1,11 @@ +{ + "skipTopLevel": false, + "firstLevel": 1, + "maxLevel": 6, + "styleLevel1": "1", + "styleLevelOther": "1", + "auto": false, + "separator": "", + "contents": "", + "startAt": "" +} \ No newline at end of file diff --git a/.obsidian/plugins/number-headings-obsidian/main.js b/.obsidian/plugins/number-headings-obsidian/main.js new file mode 100644 index 0000000..d89652a --- /dev/null +++ b/.obsidian/plugins/number-headings-obsidian/main.js @@ -0,0 +1,1112 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ROLLUP +if you want to view the source visit the plugins github repository +*/ + +'use strict'; + +var obsidian = require('obsidian'); + +/****************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ + +function __awaiter(thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +} + +function getActiveView(app) { + const activeView = app.workspace.getActiveViewOfType(obsidian.MarkdownView); + return activeView !== null && activeView !== void 0 ? activeView : undefined; +} +function isViewActive(app) { + const activeView = getActiveView(app); + if (activeView && activeView.file) + return true; + return false; +} +function getViewMetadata(app) { + const activeView = getActiveView(app); + if (activeView && activeView.file) { + const data = app.metadataCache.getFileCache(activeView.file) || {}; + return data; + } + return undefined; +} +function getViewInfo(app) { + const activeView = getActiveView(app); + const data = getViewMetadata(app); + const editor = activeView ? activeView.editor : undefined; + if (activeView && data && editor) { + return { + activeView, data, editor + }; + } + return undefined; +} + +const roman_map = { + M: 1000, + CM: 900, + D: 500, + CD: 400, + C: 100, + XC: 90, + L: 50, + XL: 40, + X: 10, + IX: 9, + V: 5, + IV: 4, + I: 1 +}; + +const allChars = Object.keys(roman_map); +const allNumerals = Object.values(roman_map); +const romanPattern = + /^(M{1,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})|M{0,4}(CM|C?D|D?C{1,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})|M{0,4}(CM|CD|D?C{0,3})(XC|X?L|L?X{1,3})(IX|IV|V?I{0,3})|M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|I?V|V?I{1,3}))$/; + +const romanize = (decimal) => { + if ( + decimal <= 0 || + typeof decimal !== 'number' || + Math.floor(decimal) !== decimal + ) { + throw new Error('requires an unsigned integer') + } + if (decimal >= 4000) { + throw new Error('requires max value of less than 3999 or less') + } + let roman = ''; + for (let i = 0; i < allChars.length; i++) { + while (decimal >= allNumerals[i]) { + decimal -= allNumerals[i]; + roman += allChars[i]; + } + } + return roman +}; + +const deromanize = (romanStr) => { + if (typeof romanStr !== 'string') { + throw new Error('requires a string') + } + if (!romanPattern.test(romanStr)) { + throw new Error('requires valid roman numeral string') + } + let romanString = romanStr.toUpperCase(); + let arabic = 0; + let iteration = romanString.length; + while (iteration--) { + let cumulative = roman_map[romanString[iteration]]; + if (cumulative < roman_map[romanString[iteration + 1]]) { + arabic -= cumulative; + } else { + arabic += cumulative; + } + } + return arabic +}; + +var romans = { + deromanize, + romanize, + allChars, + allNumerals +}; + +// Validates the string using a regex to ensure is is a valid arabic numbering value +function isValidArabicNumberingValueString(s) { + const regex = /^[0-9]+$/; + return regex.test(s); +} +// Validates the string using a regex to ensure is is a valid alphabet numbering value +function isValidAlphabetNumberingValueString(s) { + const regex = /^[A-Z]$/; + return regex.test(s); +} +// Validates the string using a regex to ensure is is a valid roman numbering value +function isValidRomanNumberingValueString(s) { + const regex = /^[0IVXLCDM]+$/; // This includes zero for zeroth testing + return regex.test(s); +} +function printableNumberingToken(t) { + switch (t.style) { + case '1': + return t.value.toString(); + case 'A': + return t.value; + case 'I': + return t.value; + } +} +function zerothNumberingTokenInStyle(style) { + switch (style) { + case '1': + return { style: '1', value: 0 }; + case 'A': + return { style: 'A', value: 'Z' }; + case 'I': + return { style: 'I', value: '0' }; + } +} +function firstNumberingTokenInStyle(style) { + switch (style) { + case '1': + return { style: '1', value: 1 }; + case 'A': + return { style: 'A', value: 'A' }; + case 'I': + return { style: 'I', value: 'I' }; + } +} +function nextNumberingToken(t) { + switch (t.style) { + case '1': + return { style: '1', value: t.value + 1 }; + case 'A': + if (t.value === 'Z') + return { style: 'A', value: 'A' }; + else + return { style: 'A', value: String.fromCharCode(t.value.charCodeAt(0) + 1) }; + case 'I': + if (t.value === '0') + return { style: 'I', value: 'I' }; + else + return { style: 'I', value: romans.romanize(romans.deromanize(t.value) + 1) }; + } +} +function previousNumberingToken(t) { + switch (t.style) { + case '1': + return { style: '1', value: t.value - 1 }; + case 'A': + if (t.value === 'A') + return { style: 'A', value: 'Z' }; + else + return { style: 'A', value: String.fromCharCode(t.value.charCodeAt(0) - 1) }; + case 'I': + if (t.value === 'I') + return { style: 'I', value: '0' }; + else + return { style: 'I', value: romans.romanize(romans.deromanize(t.value) - 1) }; + } +} +function makeNumberingString(numberingStack) { + let numberingString = ''; + for (let i = 0; i < numberingStack.length; i++) { + if (i === 0) { + numberingString += ' '; + } + else { + numberingString += '.'; + } + numberingString += printableNumberingToken(numberingStack[i]); + } + return numberingString; +} +function startAtOrZerothInStyle(startAtSettingString, style) { + if (startAtSettingString === '') + return zerothNumberingTokenInStyle(style); + let firstNumberingTokenFromSetting; + switch (style) { + case '1': + if (!isValidArabicNumberingValueString(startAtSettingString)) + return zerothNumberingTokenInStyle(style); + firstNumberingTokenFromSetting = { style: '1', value: parseInt(startAtSettingString) }; + break; + case 'A': + if (!isValidAlphabetNumberingValueString(startAtSettingString)) + return zerothNumberingTokenInStyle(style); + firstNumberingTokenFromSetting = { style: 'A', value: startAtSettingString }; + break; + case 'I': + if (!isValidRomanNumberingValueString(startAtSettingString)) + return zerothNumberingTokenInStyle(style); + firstNumberingTokenFromSetting = { style: 'I', value: startAtSettingString }; + break; + } + // Convert the first numbering token to a zeroth numbering token + return previousNumberingToken(firstNumberingTokenFromSetting); +} + +const DEFAULT_SETTINGS = { + skipTopLevel: false, + firstLevel: 1, + maxLevel: 6, + styleLevel1: '1', + styleLevelOther: '1', + auto: false, + separator: '', + contents: '', + startAt: '' +}; +function isValidNumberingStyleString(s) { + if (s === 'A' || s === '1' || s === 'I') + return true; + return false; +} +function isValidNumberingValueString(s) { + if (s === '' || isValidArabicNumberingValueString(s) || isValidAlphabetNumberingValueString(s) || isValidRomanNumberingValueString(s)) + return true; + return false; +} +function isValidFlag(f) { + if (f === true || f === false) + return true; + return false; +} +function isValidFirstOrMaxLevel(x) { + if (typeof x === 'number' && x >= 1 && x <= 6) + return true; + return false; +} +function isValidSeparator(x) { + return typeof x === 'string' && + (x === '' || + x === ':' || x === ' :' || + x === '.' || x === ' .' || + x === '-' || x === ' -' || + x === '—' || x === ' —' || /* em-dash */ + x === ')' || x === ' )'); +} +function isValidContents(x) { + if (typeof x === 'string' && (x === '' || x.startsWith('^'))) + return true; + return false; +} +function doesContentsHaveValue(x) { + if (x.length > 2 && x.startsWith('^')) + return true; + return false; +} + +function createSupportFlagsFromSettings(styleLevel1, styleLevelOther) { + return { + alphabet: styleLevel1 === 'A' || styleLevelOther === 'A', + roman: styleLevel1 === 'I' || styleLevelOther === 'I' + }; +} +function getRegexForHeaderString(flags) { + if (flags.alphabet && flags.roman) { + // Regex to match the heading prefix, including the space after the hash(es), but not the heading text + return /^\s{0,4}#+( )?([0-9]+\.|[A-Z]\.|[IVXLCDM]+\.)*([0-9]+|[A-Z]|[IVXLCDM]+)?( )?[)—:.-]?( )+/g; + } + else if (!flags.alphabet && flags.roman) { + // Regex to match the heading prefix, including the space after the hash(es), but not the heading text + return /^\s{0,4}#+( )?([0-9]+\.|[IVXLCDM]+\.)*([0-9]+|[IVXLCDM]+)?( )?[)—:.-]?( )+/g; + } + else if (flags.alphabet && !flags.roman) { + // Regex to match the heading prefix, including the space after the hash(es), but not the heading text + return /^\s{0,4}#+( )?([0-9]+\.|[A-Z]\.)*([0-9]+|[A-Z])?( )?[)—:.-]?( )+/g; + } + else if (!flags.alphabet && !flags.roman) { + // Regex to match the heading prefix, including the space after the hash(es), but not the heading text + return /^\s{0,4}#+( )?([0-9]+\.)*([0-9]+)?( )?[)—:.-]?( )+/g; + } + throw new Error('Unexpected combination of support flags'); +} +function findRangeInHeaderString(lineText, lineNumber, flags) { + const regex = getRegexForHeaderString(flags); + if (!lineText) + return undefined; + const matches = lineText.match(regex); + if (matches && matches.length !== 1) { + // eslint-disable-next-line no-console + console.log("Unexpected heading format: '" + lineText + "'"); + return undefined; + } + const match = matches ? matches[0] : ''; + const from = { + line: lineNumber, + ch: 0 + }; + const to = { + line: lineNumber, + ch: match.length + }; + return { from, to }; +} +function updateSettingsFromFrontMatterFormatPart(part, settings) { + // Parse the separator + let partWithoutSeparator = part; + const potentialTwoCharSeparator = part.slice(-2); + if (isValidSeparator(potentialTwoCharSeparator)) { + settings.separator = potentialTwoCharSeparator; + partWithoutSeparator = part.slice(0, -2); + } + else { + const potentialOneCharSeparator = part.slice(-1); + if (isValidSeparator(potentialOneCharSeparator)) { + settings.separator = potentialOneCharSeparator; + partWithoutSeparator = part.slice(0, -1); + } + else { + settings.separator = ''; + } + } + // Parse the numbering style + const descriptors = partWithoutSeparator.split('.'); + let firstNumberedDescriptor = 0; + // Handle the case where the first descriptor is an underscore + if (descriptors.length > 1 && descriptors[0] === '_') { + // The first descriptor is an instruction to skip top levels, so skip them + settings.skipTopLevel = true; + firstNumberedDescriptor = 1; + } + else { + settings.skipTopLevel = false; + } + if (descriptors.length - firstNumberedDescriptor >= 2) { + const styleLevel1 = descriptors[firstNumberedDescriptor]; + if (isValidNumberingStyleString(styleLevel1)) { + settings.styleLevel1 = styleLevel1; + } + const styleLevelOther = descriptors[firstNumberedDescriptor + 1]; + if (isValidNumberingStyleString(styleLevelOther)) { + settings.styleLevelOther = styleLevelOther; + } + } + return settings; +} + +const AUTO_PART_KEY = 'auto'; +const FIRST_LEVEL_PART_KEY = 'first-level'; +const MAX_LEVEL_PART_KEY = 'max'; +const CONTENTS_PART_KEY = 'contents'; +const START_AT_PART_KEY = 'start-at'; +function parseCompactFrontMatterSettings(fm) { + const entry = obsidian.parseFrontMatterEntry(fm, 'number headings'); + if (entry) { + const entryString = String(entry); + const parts = entryString.split(','); + let settings = Object.assign({}, DEFAULT_SETTINGS); + for (const part of parts) { + const trimmedPart = part.trim(); + if (trimmedPart.length === 0) + continue; + if (trimmedPart === AUTO_PART_KEY) { + // Parse auto numbering part + settings.auto = true; + } + else if (trimmedPart.startsWith(FIRST_LEVEL_PART_KEY)) { + // Parse first level part + const nstring = trimmedPart.substring(FIRST_LEVEL_PART_KEY.length + 1); + const n = parseInt(nstring); + if (isValidFirstOrMaxLevel(n)) { + settings.firstLevel = n; + } + } + else if (trimmedPart.startsWith(MAX_LEVEL_PART_KEY)) { + // Parse max level part + const nstring = trimmedPart.substring(MAX_LEVEL_PART_KEY.length + 1); + const n = parseInt(nstring); + if (isValidFirstOrMaxLevel(n)) { + settings.maxLevel = n; + } + } + else if (trimmedPart.startsWith(START_AT_PART_KEY)) { + // Parse "start at" part + const value = trimmedPart.substring(START_AT_PART_KEY.length + 1); + if (isValidNumberingValueString(value)) { + settings.startAt = value; + } + } + else if (trimmedPart.startsWith(CONTENTS_PART_KEY)) { + if (trimmedPart.length <= CONTENTS_PART_KEY.length + 1) + continue; + // Parse contents heading part + const tocHeading = trimmedPart.substring(CONTENTS_PART_KEY.length + 1); + if (isValidContents(tocHeading)) { + settings.contents = tocHeading; + } + } + else { + // Parse formatting part + settings = updateSettingsFromFrontMatterFormatPart(trimmedPart, settings); + } + } + return settings; + } + return undefined; +} +const getFrontMatterSettingsOrAlternative = ({ frontmatter }, alternativeSettings) => { + var _a, _b, _c, _d, _e; + if (frontmatter !== undefined) { + const decompactedSettings = parseCompactFrontMatterSettings(frontmatter); + if (decompactedSettings !== undefined) + return decompactedSettings; + // NOTE: Everything below is for backwards compatibility only + const skipTopLevelEntry = (_a = obsidian.parseFrontMatterEntry(frontmatter, 'number-headings-skip-top-level')) !== null && _a !== void 0 ? _a : obsidian.parseFrontMatterEntry(frontmatter, 'header-numbering-skip-top-level'); + const skipTopLevel = isValidFlag(skipTopLevelEntry) ? skipTopLevelEntry : alternativeSettings.skipTopLevel; + const maxLevelEntry = (_b = obsidian.parseFrontMatterEntry(frontmatter, 'number-headings-max-level')) !== null && _b !== void 0 ? _b : obsidian.parseFrontMatterEntry(frontmatter, 'header-numbering-max-level'); + const maxLevel = isValidFirstOrMaxLevel(maxLevelEntry) ? maxLevelEntry : alternativeSettings.maxLevel; + const styleLevel1Entry = String((_c = obsidian.parseFrontMatterEntry(frontmatter, 'number-headings-style-level-1')) !== null && _c !== void 0 ? _c : obsidian.parseFrontMatterEntry(frontmatter, 'header-numbering-style-level-1')); + const styleLevel1 = isValidNumberingStyleString(styleLevel1Entry) ? styleLevel1Entry : alternativeSettings.styleLevel1; + const styleLevelOtherEntry = String((_d = obsidian.parseFrontMatterEntry(frontmatter, 'number-headings-style-level-other')) !== null && _d !== void 0 ? _d : obsidian.parseFrontMatterEntry(frontmatter, 'header-numbering-style-level-other')); + const styleLevelOther = isValidNumberingStyleString(styleLevelOtherEntry) ? styleLevelOtherEntry : alternativeSettings.styleLevelOther; + const autoEntry = (_e = obsidian.parseFrontMatterEntry(frontmatter, 'number-headings-auto')) !== null && _e !== void 0 ? _e : obsidian.parseFrontMatterEntry(frontmatter, 'header-numbering-auto'); + const auto = isValidFlag(autoEntry) ? autoEntry : alternativeSettings.auto; + return Object.assign(Object.assign({}, alternativeSettings), { skipTopLevel, maxLevel, styleLevel1, styleLevelOther, auto }); + } + else { + return alternativeSettings; + } +}; +function settingsToCompactFrontMatterValue(settings) { + const autoPart = settings.auto ? 'auto, ' : ''; + const firstLevelPart = `first-level ${settings.firstLevel}, `; + const maxPart = `max ${settings.maxLevel}, `; + const contentsPart = settings.contents && settings.contents.length > 0 ? `contents ${settings.contents}, ` : ''; + const skipTopLevelString = settings.skipTopLevel ? '_.' : ''; + const stylePart = `${skipTopLevelString}${settings.styleLevel1}.${settings.styleLevelOther}${settings.separator}`; + const startAtPart = settings.startAt !== '' ? `start-at ${settings.startAt}, ` : ''; + return autoPart + firstLevelPart + maxPart + contentsPart + startAtPart + stylePart; +} +function findLineWhichStartsWith(editor, search, afterLine) { + // Find the location of the frontmatter + for (let i = afterLine; i < editor.lastLine(); i++) { + const lineString = editor.getLine(i); + if (lineString.startsWith(search)) { + return i; + } + } + return undefined; +} +const saveSettingsToFrontMatter = ({ frontmatter }, editor, settings) => { + if (frontmatter !== undefined) { + // Front matter already exists, so we'll need to insert the settings into the front matter + const frontMatterLine = frontmatter.position.start.line; + const v = settingsToCompactFrontMatterValue(settings); + const frontMatterAdditions = `number headings: ${v}\n`; + if (frontmatter['number headings'] !== undefined) { + // Key already present, replace it + const keyLine = findLineWhichStartsWith(editor, 'number headings', frontMatterLine); + if (keyLine === undefined) + throw new Error('Number Headings Plugin: "number headings" key exists but not found.'); + const from = { line: keyLine, ch: 0 }; + const to = { line: keyLine + 1, ch: 0 }; + editor.replaceRange(frontMatterAdditions, from, to); + } + else { + // Key not present, insert new key + const from = { line: frontMatterLine + 1, ch: 0 }; + const to = { line: frontMatterLine + 1, ch: 0 }; + editor.replaceRange(frontMatterAdditions, from, to); + } + } + else { + // No frontmatter found, create frontmatter from scratch + const v = settingsToCompactFrontMatterValue(settings); + const newFrontMatter = `---\nnumber headings: ${v}\n---\n\n`; + const from = { line: 0, ch: 0 }; + const to = { line: 0, ch: 0 }; + editor.replaceRange(newFrontMatter, from, to); + // Front matter does not exist, so we will create it from scratch + } +}; + +class NumberingDoneModal extends obsidian.Modal { + constructor(app, config) { + super(app); + this.config = config; + } + onOpen() { + const { contentEl, titleEl } = this; + titleEl.setText('Number Headings - Successfully Completed'); + contentEl.createEl('div', { text: this.config.message }); + contentEl.createEl('pre', { text: this.config.preformattedMessage }); + contentEl.createEl('div', { text: "Do you want to save these settings in the document's front matter?", cls: 'number-headings-question' }); + const containerForButtons = contentEl.createEl('div', { cls: 'number-headings-button-container' }); + const noButton = containerForButtons.createEl('button', {}); + noButton.setText('No'); + noButton.onClickEvent((ev) => { + this.close(); + return ev; + }); + const yesButton = containerForButtons.createEl('button', {}); + yesButton.setText('Yes, save settings in document'); + yesButton.onClickEvent((ev) => { + this.config.saveSettingsCallback(false); + this.close(); + return ev; + }); + const yesAndAutoButton = containerForButtons.createEl('button', {}); + yesAndAutoButton.setText('Yes, save settings in document, and automatically number'); + yesAndAutoButton.onClickEvent((ev) => { + this.config.saveSettingsCallback(true); + this.close(); + return ev; + }); + } + onClose() { + const { contentEl, titleEl } = this; + contentEl.empty(); + titleEl.empty(); + } +} +function showNumberingDoneMessage(app, settings, viewInfo) { + const saveSettingsCallback = (shouldAddAutoFlag) => { + const tweakedSettings = Object.assign({}, settings); + if (shouldAddAutoFlag) + tweakedSettings.auto = true; + saveSettingsToFrontMatter(viewInfo.data, viewInfo.editor, tweakedSettings); + }; + const config = { + message: `Successfully updated all heading numbers in the document, using the settings below. + See settings panel to change how headings are numbered, or use front matter + (see settings panel).`, + preformattedMessage: `Skip top heading level: ${settings.skipTopLevel} +First heading level: ${settings.firstLevel} +Start numbering first heading at: ${settings.startAt} +Maximum heading level: ${settings.maxLevel} +Style for level 1 headings: ${settings.styleLevel1} +Style for lower level headings (below level 1): ${settings.styleLevelOther} +Separator: ${settings.separator} +Table of Contents Anchor: ${settings.contents}`, + saveSettingsCallback + }; + const leaf = app.workspace.activeLeaf; + if (leaf) { + new NumberingDoneModal(app, config).open(); + } +} + +const TOC_LIST_ITEM_BULLET = '-'; +function makeHeadingHashString(editor, heading) { + const regex = /^\s{0,4}#+/g; + const headingLineString = editor.getLine(heading.position.start.line); + if (!headingLineString) + return undefined; + const matches = headingLineString.match(regex); + if (!matches) + return undefined; + if (matches.length !== 1) { + // eslint-disable-next-line no-console + console.log("Unexpected heading format: '" + headingLineString + "'"); + return undefined; + } + const match = matches[0]; + return match.trimLeft(); +} +function findHeadingPrefixRange(editor, heading, flags) { + const lineNumber = heading.position.start.line; + const lineText = editor.getLine(lineNumber); + return findRangeInHeaderString(lineText, lineNumber, flags); +} +function cleanHeadingTextForToc(htext) { + if (htext.contains('^')) { + const x = htext.split('^'); + if (x.length > 1) { + return x[0].trim(); + } + } + return htext.trim(); +} +// eslint-disable-next-line @typescript-eslint/no-unused-vars +function createTocEntry(h, settings, initialHeadingLevel) { + const text = h.heading; + const cleanText = cleanHeadingTextForToc(text); + let bulletIndent = ''; + const startLevel = initialHeadingLevel; + for (let i = startLevel; i < h.level; i++) { + bulletIndent += '\t'; + } + const entryLink = `[[#${text}|${cleanText}]]`; + return bulletIndent + TOC_LIST_ITEM_BULLET + ' ' + entryLink; +} +// Replace a range, but only if there is a change in text, to prevent poluting the undo stack +function replaceRangeEconomically(editor, changes, range, text) { + const previousText = editor.getRange(range.from, range.to); + if (previousText !== text) { + changes.push({ + text: text, + from: range.from, + to: range.to + }); + } +} +const updateHeadingNumbering = (viewInfo, settings) => { + var _a; + if (!viewInfo) + return; + const headings = (_a = viewInfo.data.headings) !== null && _a !== void 0 ? _a : []; + const editor = viewInfo.editor; + const supportFlags = createSupportFlagsFromSettings(settings.styleLevel1, settings.styleLevelOther); + let previousLevel = 1; + let numberingStack = [startAtOrZerothInStyle(settings.startAt, settings.styleLevel1)]; + if (settings.firstLevel > 1) { + previousLevel = settings.firstLevel; + } + else if (settings.skipTopLevel) { + previousLevel = 2; + } + const changes = []; + for (const heading of headings) { + // Update the numbering stack based on the level and previous level + const level = heading.level; + // Handle skipped & ignored levels. + if ((settings.firstLevel > level) || (settings.skipTopLevel && level === 1)) { + // Resets the numbering when a level is skipped. + // Note: This leaves headings as they are, allowing people to have numbers at the start of + // ignored headings. + numberingStack = [startAtOrZerothInStyle(settings.startAt, settings.styleLevel1)]; + if (settings.firstLevel > 1) { + previousLevel = settings.firstLevel; + } + else if (settings.skipTopLevel) { + previousLevel = 2; + } + continue; + } + // Adjust numbering stack + if (level === previousLevel) { + const x = numberingStack.pop(); + if (x !== undefined) { + numberingStack.push(nextNumberingToken(x)); + } + } + else if (level < previousLevel) { + for (let i = previousLevel; i > level; i--) { + numberingStack.pop(); + } + const x = numberingStack.pop(); + if (x !== undefined) { + numberingStack.push(nextNumberingToken(x)); + } + } + else if (level > previousLevel) { + for (let i = previousLevel; i < level; i++) { + numberingStack.push(firstNumberingTokenInStyle(settings.styleLevelOther)); + } + } + // Set the previous level to this level for the next iteration + previousLevel = level; + if (level > settings.maxLevel) { + // If we are above the max level, just don't number it + continue; + } + // Find the range to replace, and then do it + const prefixRange = findHeadingPrefixRange(editor, heading, supportFlags); + if (prefixRange === undefined) + return; + const headingHashString = makeHeadingHashString(editor, heading); + if (headingHashString === undefined) + return; + const prefixString = makeNumberingString(numberingStack); + replaceRangeEconomically(editor, changes, prefixRange, headingHashString + prefixString + settings.separator + ' '); + } + // Execute the transaction to make all the changes at once + if (changes.length > 0) { + // eslint-disable-next-line no-console + console.log('Number Headings Plugin: Applying headings numbering changes:', changes.length); + editor.transaction({ + changes: changes + }); + } +}; +const updateTableOfContents = (viewInfo, settings) => { + var _a; + if (!viewInfo) + return; + const headings = (_a = viewInfo.data.headings) !== null && _a !== void 0 ? _a : []; + const editor = viewInfo.editor; + if (!doesContentsHaveValue(settings.contents)) + return; + let tocHeading; + let tocBuilder = '\n'; + const changes = []; + // In case headings start above level 1, we don't want to indent the bullets too much + let initialHeadingLevel = 1; + if (headings.length > 0) { + initialHeadingLevel = headings[0].level; + } + for (const heading of headings) { + // ORDERING: Important to find the TOC heading before skipping skipped headings, since that is for numbering + // Find the TOC heading + if (heading.heading.endsWith(settings.contents)) { + tocHeading = heading; + } + /* This code lets us skip TOC lines for skipped headings, but doesn't work well with first-level setting + if ((settings.skipTopLevel && heading.level === 1) || (heading.level > settings.maxLevel)) { + continue + } + */ + const tocEntry = createTocEntry(heading, settings, initialHeadingLevel); + tocBuilder += tocEntry + '\n'; + } + // Insert the generated table of contents + if (tocHeading) { + const from = { + line: tocHeading.position.start.line + 1, + ch: 0 + }; + // Find the end of the TOC section + const startingLine = tocHeading.position.start.line + 1; + let endingLine = startingLine; + let foundList = false; + const lastLineInEditor = editor.lastLine(); + for (;; endingLine++) { + const line = editor.getLine(endingLine); + if (line === undefined || endingLine > lastLineInEditor) { + // Reached end of file, insert at the start of the TOC section + endingLine = startingLine; + break; + } + const trimmedLineText = line.trimStart(); + if (foundList) { + if (!trimmedLineText.startsWith(TOC_LIST_ITEM_BULLET)) + break; + if (trimmedLineText.startsWith('#')) + break; + } + else { + if (trimmedLineText.startsWith(TOC_LIST_ITEM_BULLET)) { + foundList = true; + } + else if (trimmedLineText.startsWith('#')) { + // Reached the next heading without finding existing TOC list, insert at the start of the TOC section + endingLine = startingLine; + break; + } + else { + continue; + } + } + } + if (tocBuilder === '\n') { + tocBuilder = ''; + } + const to = { + line: endingLine, + ch: 0 + }; + const range = { from, to }; + replaceRangeEconomically(editor, changes, range, tocBuilder); + } + // Execute the transaction to make all the changes at once + if (changes.length > 0) { + // eslint-disable-next-line no-console + console.log('Number Headings Plugin: Applying table of contents changes:', changes.length); + editor.transaction({ + changes: changes + }); + } +}; +const removeHeadingNumbering = (viewInfo) => { + var _a; + if (!viewInfo) + return; + const headings = (_a = viewInfo.data.headings) !== null && _a !== void 0 ? _a : []; + const editor = viewInfo.editor; + const changes = []; + for (const heading of headings) { + const prefixRange = findHeadingPrefixRange(editor, heading, { alphabet: true, roman: true }); + if (prefixRange === undefined) + return; + const headingHashString = makeHeadingHashString(editor, heading); + if (headingHashString === undefined) + return; + replaceRangeEconomically(editor, changes, prefixRange, headingHashString + ' '); + } + if (changes.length > 0) { + editor.transaction({ + changes: changes + }); + } +}; + +class NumberHeadingsPluginSettingTab extends obsidian.PluginSettingTab { + constructor(app, plugin) { + super(app, plugin); + this.plugin = plugin; + } + display() { + const { containerEl } = this; + containerEl.empty(); + containerEl.createEl('h2', { text: 'Number Headings - Settings' }); + containerEl.createEl('div', { text: 'To add numbering to your document, bring up the command window (on Mac, type CMD+P), and then type "Number Headings" to see a list of available commands.' }); + containerEl.createEl('br', {}); + containerEl.createEl('div', { text: 'If the document has front matter defined with the below settings, the project-wide settings defined on this screen will be ignored. You can define front matter like this:' }); + containerEl.createEl('pre', { + text: ` --- + alias: + - Example Alias + tags: + - example-tag + number headings: first-level 1, start-at 2, max 6, 1.1, auto, contents ^toc + ---` + }); + containerEl.createEl('div', { + text: ` + The 'number headings' front matter key is used to store numbering settings specific to the file. There are four possible options + in the value to the right of the colon, separated by commas. + ` + }); + const ul = containerEl.createEl('ul', {}); + const li0 = ul.createEl('li', {}); + li0.createEl('b', { text: 'Automatic numbering' }); + li0.createEl('span', { text: ': If \'auto\' appears, the document will be automatically numbered.' }); + const li1 = ul.createEl('li', {}); + li1.createEl('b', { text: 'First level to number' }); + li1.createEl('span', { text: ': If \'first-level 2\' appears, the numbering will start at the second level' }); + const li2 = ul.createEl('li', {}); + li2.createEl('b', { text: 'Start numbering first heading at' }); + li2.createEl('span', { text: ': If \'start-at C\' appears, the numbering of the first level will start at C, instead of A' }); + const li3 = ul.createEl('li', {}); + li3.createEl('b', { text: 'Maximum level to number' }); + li3.createEl('span', { text: ': If \'max 6\' appears, the headings above level 6 will be skipped.' }); + const li4 = ul.createEl('li', {}); + li4.createEl('b', { text: 'Table of contents anchor' }); + li4.createEl('span', { text: ': If \'contents ^toc\' appears, the heading that ends with the anchor ^toc will have a table of contents inserted beneath it.' }); + const li5 = ul.createEl('li', {}); + li5.createEl('b', { text: 'Numbering style' }); + li5.createEl('span', { + text: `: + A style text like '1.1', 'A.1', or '_.1.1' tells the plugin how to format the headings. + If a style string ends with '.' (a dot), ':' (a colon), '-' (a dash), '—' (an emdash), or ')' (a right parenthesis), the heading numbers will be separated from the heading title + with that symbol.` + }); + const ul3 = li5.createEl('ul', {}); + ul3.createEl('li', { + text: ` + For example, '1.1' means both top level and other headings will be numbered starting from '1'. + ` + }); + ul3.createEl('li', { + text: ` + For example, 'A.1' means top level headings will be numbered starting from 'A'. + ` + }); + ul3.createEl('li', { + text: ` + For example, '_.A.1' means top level headings will NOT be numbered, but the next levels will be numbered with letters and numbers. + ` + }); + ul3.createEl('li', { + text: ` + For example, '1.1:' means headings will look like '## 2.4: Example Heading' + ` + }); + ul3.createEl('li', { + text: ` + For example, 'A.1-' means headings will look like '## B.5- Example Heading' + ` + }); + ul3.createEl('li', { + text: ` + For example, 'I.A —' means headings will look like '## IV.A — Example Heading' (with Roman numerals) + ` + }); + new obsidian.Setting(containerEl) + .setName('Skip top heading level') + .setDesc('If selected, numbering will not be applied to the top heading level.') + .addToggle(toggle => toggle + .setValue(this.plugin.settings.skipTopLevel) + .setTooltip('Skip top heading level') + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.skipTopLevel = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('First heading level') + .setDesc('First heading level to number.') + .addSlider(slider => slider + .setLimits(1, 6, 1) + .setValue(this.plugin.settings.firstLevel) + .setDynamicTooltip() + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.firstLevel = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Start numbering at') + .setDesc('Start numbering the first heading level from this value.') + .addText(text => text + .setValue(this.plugin.settings.startAt) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.startAt = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Maximum heading level') + .setDesc('Maximum heading level to number.') + .addSlider(slider => slider + .setLimits(1, 6, 1) + .setValue(this.plugin.settings.maxLevel) + .setDynamicTooltip() + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.maxLevel = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Style for level 1 headings') + .setDesc('Defines the numbering style for level one headings. Valid values are 1 (for numbers) or A (for capital letters) or I (for Roman numerals).') + .addText(text => text + .setValue(this.plugin.settings.styleLevel1) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.styleLevel1 = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Style for lower level headings (below level 1)') + .setDesc('Defines the numbering style for headings below level one. Valid values are 1 (for numbers) or A (for capital letters) or I (for Roman numerals).') + .addText(text => text + .setValue(this.plugin.settings.styleLevelOther) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.styleLevelOther = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Automatic numbering') + .setDesc('Turns on automatic numbering of documents.') + .addToggle(toggle => toggle + .setValue(this.plugin.settings.auto) + .setTooltip('Turn on automatic numbering') + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.auto = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Separator style') + .setDesc('Defines the separator style between the heading number and the heading text. Valid values are : (colon) or . (dot) or - (dash) or — (emdash) or ) (a right parenthesis). You can also leave it blank for no separator, or have a space before the separator.') + .addText(text => text + .setValue(this.plugin.settings.separator) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.separator = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Table of Contents Anchor') + .setDesc('Anchor which labels the header where a table of contents should be inserted. The anchor should be added at the end of a header. For example, ^toc.') + .addText(text => text + .setValue(this.plugin.settings.contents) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.contents = value; + yield this.plugin.saveSettings(); + }))); + } +} +class NumberHeadingsPlugin extends obsidian.Plugin { + onload() { + return __awaiter(this, void 0, void 0, function* () { + // eslint-disable-next-line no-console + console.info('Loading Number Headings Plugin, version ' + this.manifest.version); + yield this.loadSettings(); + this.addCommand({ + id: 'number-headings-with-options', + name: 'Number all headings in document (and show options)', + checkCallback: (checking) => { + if (checking) + return isViewActive(this.app); + const viewInfo = getViewInfo(this.app); + if (viewInfo) { + const settings = getFrontMatterSettingsOrAlternative(viewInfo.data, this.settings); + updateHeadingNumbering(viewInfo, settings); + setTimeout(() => { + // HACK: This must happen after a timeout so that there is time for the editor transaction to complete + const postNumberingViewInfo = getViewInfo(this.app); + updateTableOfContents(postNumberingViewInfo, settings); + }, 3000); + showNumberingDoneMessage(this.app, settings, viewInfo); + } + return false; + } + }); + this.addCommand({ + id: 'number-headings', + name: 'Number all headings in document', + checkCallback: (checking) => { + if (checking) + return isViewActive(this.app); + const viewInfo = getViewInfo(this.app); + if (viewInfo) { + const settings = getFrontMatterSettingsOrAlternative(viewInfo.data, this.settings); + updateHeadingNumbering(viewInfo, settings); + setTimeout(() => { + // HACK: This must happen after a timeout so that there is time for the editor transaction to complete + const postNumberingViewInfo = getViewInfo(this.app); + updateTableOfContents(postNumberingViewInfo, settings); + }, 3000); + // NOTE: The line below is intentionally commented out, since this command is the same as + // the above command, except for this line + // showNumberingDoneMessage(this.app, settings, viewInfo) + } + return false; + } + }); + this.addCommand({ + id: 'remove-number-headings', + name: 'Remove numbering from all headings in document', + checkCallback: (checking) => { + if (checking) + return isViewActive(this.app); + const viewInfo = getViewInfo(this.app); + removeHeadingNumbering(viewInfo); + return true; + } + }); + this.addCommand({ + id: 'save-settings-to-front-matter', + name: 'Save settings to front matter', + checkCallback: (checking) => { + if (checking) + return isViewActive(this.app); + const viewInfo = getViewInfo(this.app); + if (viewInfo) { + const settings = getFrontMatterSettingsOrAlternative(viewInfo.data, this.settings); + saveSettingsToFrontMatter(viewInfo.data, viewInfo.editor, settings); + } + return false; + } + }); + this.addSettingTab(new NumberHeadingsPluginSettingTab(this.app, this)); + this.registerInterval(window.setInterval(() => { + const viewInfo = getViewInfo(this.app); + if (viewInfo) { + const settings = getFrontMatterSettingsOrAlternative(viewInfo.data, this.settings); + if (settings.auto) { + updateHeadingNumbering(viewInfo, settings); + setTimeout(() => { + // HACK: This must happen after a timeout so that there is time for the editor transaction to complete + const postNumberingViewInfo = getViewInfo(this.app); + updateTableOfContents(postNumberingViewInfo, settings); + }, 3000); + // eslint-disable-next-line no-console + console.log('Number Headings Plugin: Automatically numbered document'); + } + } + }, 10 * 1000)); + }); + } + loadSettings() { + return __awaiter(this, void 0, void 0, function* () { + this.settings = Object.assign({}, DEFAULT_SETTINGS, yield this.loadData()); + }); + } + saveSettings() { + return __awaiter(this, void 0, void 0, function* () { + yield this.saveData(this.settings); + }); + } +} + +module.exports = NumberHeadingsPlugin; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["node_modules/tslib/tslib.es6.js","src/activeViewHelpers.ts","node_modules/romans/romans.js","src/numberingTokens.ts","src/settingsTypes.ts","src/textProcessing.ts","src/frontMatter.ts","src/messages.ts","src/numbering.ts","src/main.ts"],"sourcesContent":["/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n","import { App, CachedMetadata, Editor, MarkdownView } from 'obsidian'\n\nfunction getActiveView (app: App): MarkdownView | undefined {\n  const activeView = app.workspace.getActiveViewOfType(MarkdownView)\n  return activeView ?? undefined\n}\n\nexport function isViewActive (app: App): boolean {\n  const activeView = getActiveView(app)\n  if (activeView && activeView.file) return true\n  return false\n}\n\nfunction getViewMetadata (app: App): CachedMetadata | undefined {\n  const activeView = getActiveView(app)\n  if (activeView && activeView.file) {\n    const data = app.metadataCache.getFileCache(activeView.file) || {}\n    return data\n  }\n  return undefined\n}\n\nexport interface ViewInfo {\n  activeView: MarkdownView\n  data: CachedMetadata\n  editor: Editor\n}\n\nexport function getViewInfo (app: App): ViewInfo | undefined {\n  const activeView = getActiveView(app)\n  const data = getViewMetadata(app)\n  const editor = activeView ? activeView.editor : undefined\n\n  if (activeView && data && editor) {\n    return {\n      activeView, data, editor\n    }\n  }\n\n  return undefined\n}\n","const roman_map = {\n  M: 1000,\n  CM: 900,\n  D: 500,\n  CD: 400,\n  C: 100,\n  XC: 90,\n  L: 50,\n  XL: 40,\n  X: 10,\n  IX: 9,\n  V: 5,\n  IV: 4,\n  I: 1\n}\n\nconst allChars = Object.keys(roman_map)\nconst allNumerals = Object.values(roman_map)\nconst romanPattern =\n  /^(M{1,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})|M{0,4}(CM|C?D|D?C{1,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})|M{0,4}(CM|CD|D?C{0,3})(XC|X?L|L?X{1,3})(IX|IV|V?I{0,3})|M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|I?V|V?I{1,3}))$/\n\nconst romanize = (decimal) => {\n  if (\n    decimal <= 0 ||\n    typeof decimal !== 'number' ||\n    Math.floor(decimal) !== decimal\n  ) {\n    throw new Error('requires an unsigned integer')\n  }\n  if (decimal >= 4000) {\n    throw new Error('requires max value of less than 3999 or less')\n  }\n  let roman = ''\n  for (let i = 0; i < allChars.length; i++) {\n    while (decimal >= allNumerals[i]) {\n      decimal -= allNumerals[i]\n      roman += allChars[i]\n    }\n  }\n  return roman\n}\n\nconst deromanize = (romanStr) => {\n  if (typeof romanStr !== 'string') {\n    throw new Error('requires a string')\n  }\n  if (!romanPattern.test(romanStr)) {\n    throw new Error('requires valid roman numeral string')\n  }\n  let romanString = romanStr.toUpperCase()\n  let arabic = 0\n  let iteration = romanString.length\n  while (iteration--) {\n    let cumulative = roman_map[romanString[iteration]]\n    if (cumulative < roman_map[romanString[iteration + 1]]) {\n      arabic -= cumulative\n    } else {\n      arabic += cumulative\n    }\n  }\n  return arabic\n}\n\nmodule.exports = {\n  deromanize,\n  romanize,\n  allChars,\n  allNumerals\n}\n","import { deromanize, romanize } from 'romans'\n\nexport type NumberingToken = NumberingTokenArabic | NumberingTokenAlphabet | NumberingTokenRoman\nexport type NumberingTokenArabic = {\n  style: '1'\n  value: number\n}\nexport type NumberingTokenAlphabet = {\n  style: 'A'\n  value: string\n}\nexport type NumberingTokenRoman = {\n  style: 'I'\n  value: string\n}\nexport type NumberingStyle = '1' | 'A' | 'I'\nexport type NumberingValue = number | string\n\n// Validates the string using a regex to ensure is is a valid arabic numbering value\nexport function isValidArabicNumberingValueString (s: string): boolean {\n  const regex = /^[0-9]+$/\n  return regex.test(s)\n}\n\n// Validates the string using a regex to ensure is is a valid alphabet numbering value\nexport function isValidAlphabetNumberingValueString (s: string): boolean {\n  const regex = /^[A-Z]$/\n  return regex.test(s)\n}\n\n// Validates the string using a regex to ensure is is a valid roman numbering value\nexport function isValidRomanNumberingValueString (s: string): boolean {\n  const regex = /^[0IVXLCDM]+$/ // This includes zero for zeroth testing\n  return regex.test(s)\n}\n\nfunction printableNumberingToken (t: NumberingToken): string {\n  switch (t.style) {\n    case '1':\n      return t.value.toString()\n    case 'A':\n      return t.value\n    case 'I':\n      return t.value\n  }\n}\n\nexport function zerothNumberingTokenInStyle (style: NumberingStyle): NumberingToken {\n  switch (style) {\n    case '1':\n      return { style: '1', value: 0 }\n    case 'A':\n      return { style: 'A', value: 'Z' }\n    case 'I':\n      return { style: 'I', value: '0' }\n  }\n}\n\nexport function firstNumberingTokenInStyle (style: NumberingStyle): NumberingToken {\n  switch (style) {\n    case '1':\n      return { style: '1', value: 1 }\n    case 'A':\n      return { style: 'A', value: 'A' }\n    case 'I':\n      return { style: 'I', value: 'I' }\n  }\n}\n\nexport function nextNumberingToken (t: NumberingToken): NumberingToken {\n  switch (t.style) {\n    case '1':\n      return { style: '1', value: t.value + 1 }\n    case 'A':\n      if (t.value === 'Z') return { style: 'A', value: 'A' }\n      else return { style: 'A', value: String.fromCharCode(t.value.charCodeAt(0) + 1) }\n    case 'I':\n      if (t.value === '0') return { style: 'I', value: 'I' }\n      else return { style: 'I', value: romanize(deromanize(t.value) + 1) }\n  }\n}\n\nexport function previousNumberingToken (t: NumberingToken): NumberingToken {\n  switch (t.style) {\n    case '1':\n      return { style: '1', value: t.value - 1 }\n    case 'A':\n      if (t.value === 'A') return { style: 'A', value: 'Z' }\n      else return { style: 'A', value: String.fromCharCode(t.value.charCodeAt(0) - 1) }\n    case 'I':\n      if (t.value === 'I') return { style: 'I', value: '0' }\n      else return { style: 'I', value: romanize(deromanize(t.value) - 1) }\n  }\n}\n\nexport function makeNumberingString (numberingStack: NumberingToken[]): string {\n  let numberingString = ''\n\n  for (let i = 0; i < numberingStack.length; i++) {\n    if (i === 0) {\n      numberingString += ' '\n    } else {\n      numberingString += '.'\n    }\n    numberingString += printableNumberingToken(numberingStack[i])\n  }\n\n  return numberingString\n}\n\nexport function startAtOrZerothInStyle (startAtSettingString: string, style : NumberingStyle): NumberingToken {\n  if (startAtSettingString === '') return zerothNumberingTokenInStyle(style)\n\n  let firstNumberingTokenFromSetting: NumberingToken\n\n  switch (style) {\n    case '1':\n      if (!isValidArabicNumberingValueString(startAtSettingString)) return zerothNumberingTokenInStyle(style)\n\n      firstNumberingTokenFromSetting = { style: '1', value: parseInt(startAtSettingString) }\n      break\n    case 'A':\n      if (!isValidAlphabetNumberingValueString(startAtSettingString)) return zerothNumberingTokenInStyle(style)\n\n      firstNumberingTokenFromSetting = { style: 'A', value: startAtSettingString }\n      break\n    case 'I':\n      if (!isValidRomanNumberingValueString(startAtSettingString)) return zerothNumberingTokenInStyle(style)\n      firstNumberingTokenFromSetting = { style: 'I', value: startAtSettingString }\n      break\n  }\n\n  // Convert the first numbering token to a zeroth numbering token\n  return previousNumberingToken(firstNumberingTokenFromSetting)\n}\n","import { isValidAlphabetNumberingValueString, isValidArabicNumberingValueString, isValidRomanNumberingValueString, NumberingStyle } from './numberingTokens'\n\nexport interface NumberHeadingsPluginSettings {\n  skipTopLevel: boolean,\n  firstLevel: number,\n  maxLevel: number,\n  styleLevel1: NumberingStyle,\n  styleLevelOther: NumberingStyle,\n  auto: boolean,\n  separator: string,\n  contents: string,\n  startAt: string,\n}\n\nexport const DEFAULT_SETTINGS: Readonly<NumberHeadingsPluginSettings> = {\n  skipTopLevel: false,\n  firstLevel: 1,\n  maxLevel: 6,\n  styleLevel1: '1',\n  styleLevelOther: '1',\n  auto: false,\n  separator: '',\n  contents: '',\n  startAt: ''\n}\n\nexport function isValidNumberingStyleString (s: string): boolean {\n  if (s === 'A' || s === '1' || s === 'I') return true\n  return false\n}\n\nexport function isValidNumberingValueString (s: string): boolean {\n  if (s === '' || isValidArabicNumberingValueString(s) || isValidAlphabetNumberingValueString(s) || isValidRomanNumberingValueString(s)) return true\n  return false\n}\n\nexport function isValidFlag (f: unknown): boolean {\n  if (f === true || f === false) return true\n  return false\n}\n\nexport function isValidFirstOrMaxLevel (x: unknown): boolean {\n  if (typeof x === 'number' && x >= 1 && x <= 6) return true\n  return false\n}\n\nexport function isValidSeparator (x: unknown): boolean {\n  return typeof x === 'string' &&\n    (\n      x === '' ||\n      x === ':' || x === ' :' ||\n      x === '.' || x === ' .' ||\n      x === '-' || x === ' -' ||\n      x === '—' || x === ' —' || /* em-dash */\n      x === ')' || x === ' )'\n    )\n}\n\nexport function isValidContents (x: unknown): boolean {\n  if (typeof x === 'string' && (x === '' || x.startsWith('^'))) return true\n  return false\n}\n\nexport function doesContentsHaveValue (x: string): boolean {\n  if (x.length > 2 && x.startsWith('^')) return true\n  return false\n}\n","import { EditorRange } from 'obsidian'\nimport { NumberingStyle } from './numberingTokens'\nimport { isValidNumberingStyleString, isValidSeparator, NumberHeadingsPluginSettings } from './settingsTypes'\n\nexport type SupportFlags = {\n  alphabet: boolean,\n  roman: boolean,\n}\n\nexport function createSupportFlagsFromSettings (styleLevel1: string, styleLevelOther: string): SupportFlags {\n  return {\n    alphabet: styleLevel1 === 'A' || styleLevelOther === 'A',\n    roman: styleLevel1 === 'I' || styleLevelOther === 'I'\n  }\n}\n\nfunction getRegexForHeaderString (flags: SupportFlags): RegExp {\n  if (flags.alphabet && flags.roman) {\n    // Regex to match the heading prefix, including the space after the hash(es), but not the heading text\n    return /^\\s{0,4}#+( )?([0-9]+\\.|[A-Z]\\.|[IVXLCDM]+\\.)*([0-9]+|[A-Z]|[IVXLCDM]+)?( )?[)—:.-]?( )+/g\n  } else if (!flags.alphabet && flags.roman) {\n    // Regex to match the heading prefix, including the space after the hash(es), but not the heading text\n    return /^\\s{0,4}#+( )?([0-9]+\\.|[IVXLCDM]+\\.)*([0-9]+|[IVXLCDM]+)?( )?[)—:.-]?( )+/g\n  } else if (flags.alphabet && !flags.roman) {\n    // Regex to match the heading prefix, including the space after the hash(es), but not the heading text\n    return /^\\s{0,4}#+( )?([0-9]+\\.|[A-Z]\\.)*([0-9]+|[A-Z])?( )?[)—:.-]?( )+/g\n  } else if (!flags.alphabet && !flags.roman) {\n    // Regex to match the heading prefix, including the space after the hash(es), but not the heading text\n    return /^\\s{0,4}#+( )?([0-9]+\\.)*([0-9]+)?( )?[)—:.-]?( )+/g\n  }\n\n  throw new Error('Unexpected combination of support flags')\n}\n\nexport function findRangeInHeaderString (lineText: string, lineNumber: number, flags: SupportFlags): EditorRange | undefined {\n  const regex = getRegexForHeaderString(flags)\n\n  if (!lineText) return undefined\n\n  const matches = lineText.match(regex)\n\n  if (matches && matches.length !== 1) {\n    // eslint-disable-next-line no-console\n    console.log(\"Unexpected heading format: '\" + lineText + \"'\")\n    return undefined\n  }\n\n  const match = matches ? matches[0] : ''\n\n  const from = {\n    line: lineNumber,\n    ch: 0\n  }\n  const to = {\n    line: lineNumber,\n    ch: match.length\n  }\n\n  return { from, to }\n}\n\nexport function updateSettingsFromFrontMatterFormatPart (part: string, settings: NumberHeadingsPluginSettings): NumberHeadingsPluginSettings {\n  // Parse the separator\n  let partWithoutSeparator = part\n  const potentialTwoCharSeparator = part.slice(-2)\n  if (isValidSeparator(potentialTwoCharSeparator)) {\n    settings.separator = potentialTwoCharSeparator\n    partWithoutSeparator = part.slice(0, -2)\n  } else {\n    const potentialOneCharSeparator = part.slice(-1)\n    if (isValidSeparator(potentialOneCharSeparator)) {\n      settings.separator = potentialOneCharSeparator\n      partWithoutSeparator = part.slice(0, -1)\n    } else {\n      settings.separator = ''\n    }\n  }\n\n  // Parse the numbering style\n  const descriptors = partWithoutSeparator.split('.')\n  let firstNumberedDescriptor = 0\n\n  // Handle the case where the first descriptor is an underscore\n  if (descriptors.length > 1 && descriptors[0] === '_') {\n    // The first descriptor is an instruction to skip top levels, so skip them\n    settings.skipTopLevel = true\n    firstNumberedDescriptor = 1\n  } else {\n    settings.skipTopLevel = false\n  }\n\n  if (descriptors.length - firstNumberedDescriptor >= 2) {\n    const styleLevel1 = descriptors[firstNumberedDescriptor]\n    if (isValidNumberingStyleString(styleLevel1)) {\n      settings.styleLevel1 = styleLevel1 as NumberingStyle\n    }\n    const styleLevelOther = descriptors[firstNumberedDescriptor + 1]\n    if (isValidNumberingStyleString(styleLevelOther)) {\n      settings.styleLevelOther = styleLevelOther as NumberingStyle\n    }\n  }\n\n  return settings\n}\n","import { CachedMetadata, Editor, EditorPosition, FrontMatterCache, parseFrontMatterEntry } from 'obsidian'\nimport { NumberingStyle } from './numberingTokens'\nimport { DEFAULT_SETTINGS, isValidContents, isValidFirstOrMaxLevel, isValidFlag, isValidNumberingStyleString, isValidNumberingValueString, NumberHeadingsPluginSettings } from './settingsTypes'\nimport { updateSettingsFromFrontMatterFormatPart } from './textProcessing'\n\nconst AUTO_PART_KEY = 'auto'\nconst FIRST_LEVEL_PART_KEY = 'first-level'\nconst MAX_LEVEL_PART_KEY = 'max'\nconst CONTENTS_PART_KEY = 'contents'\nconst START_AT_PART_KEY = 'start-at'\n\nfunction parseCompactFrontMatterSettings (fm: FrontMatterCache): NumberHeadingsPluginSettings | undefined {\n  const entry = parseFrontMatterEntry(fm, 'number headings')\n  if (entry) {\n    const entryString = String(entry)\n    const parts = entryString.split(',')\n    let settings: NumberHeadingsPluginSettings = { ...DEFAULT_SETTINGS }\n\n    for (const part of parts) {\n      const trimmedPart = part.trim()\n      if (trimmedPart.length === 0) continue\n\n      if (trimmedPart === AUTO_PART_KEY) {\n        // Parse auto numbering part\n        settings.auto = true\n      } else if (trimmedPart.startsWith(FIRST_LEVEL_PART_KEY)) {\n        // Parse first level part\n        const nstring = trimmedPart.substring(FIRST_LEVEL_PART_KEY.length + 1)\n        const n = parseInt(nstring)\n        if (isValidFirstOrMaxLevel(n)) {\n          settings.firstLevel = n\n        }\n      } else if (trimmedPart.startsWith(MAX_LEVEL_PART_KEY)) {\n        // Parse max level part\n        const nstring = trimmedPart.substring(MAX_LEVEL_PART_KEY.length + 1)\n        const n = parseInt(nstring)\n        if (isValidFirstOrMaxLevel(n)) {\n          settings.maxLevel = n\n        }\n      } else if (trimmedPart.startsWith(START_AT_PART_KEY)) {\n        // Parse \"start at\" part\n        const value = trimmedPart.substring(START_AT_PART_KEY.length + 1)\n        if (isValidNumberingValueString(value)) {\n          settings.startAt = value\n        }\n      } else if (trimmedPart.startsWith(CONTENTS_PART_KEY)) {\n        if (trimmedPart.length <= CONTENTS_PART_KEY.length + 1) continue\n        // Parse contents heading part\n        const tocHeading = trimmedPart.substring(CONTENTS_PART_KEY.length + 1)\n        if (isValidContents(tocHeading)) {\n          settings.contents = tocHeading\n        }\n      } else {\n        // Parse formatting part\n        settings = updateSettingsFromFrontMatterFormatPart(trimmedPart, settings)\n      }\n    }\n\n    return settings\n  }\n\n  return undefined\n}\n\nexport const getFrontMatterSettingsOrAlternative = (\n  { frontmatter }: CachedMetadata,\n  alternativeSettings: NumberHeadingsPluginSettings\n): NumberHeadingsPluginSettings => {\n  if (frontmatter !== undefined) {\n    const decompactedSettings = parseCompactFrontMatterSettings(frontmatter)\n    if (decompactedSettings !== undefined) return decompactedSettings\n\n    // NOTE: Everything below is for backwards compatibility only\n\n    const skipTopLevelEntry = parseFrontMatterEntry(frontmatter, 'number-headings-skip-top-level') ?? parseFrontMatterEntry(frontmatter, 'header-numbering-skip-top-level')\n    const skipTopLevel = isValidFlag(skipTopLevelEntry) ? skipTopLevelEntry : alternativeSettings.skipTopLevel\n\n    const maxLevelEntry = parseFrontMatterEntry(frontmatter, 'number-headings-max-level') ?? parseFrontMatterEntry(frontmatter, 'header-numbering-max-level')\n    const maxLevel = isValidFirstOrMaxLevel(maxLevelEntry) ? maxLevelEntry : alternativeSettings.maxLevel\n\n    const styleLevel1Entry = String(\n      parseFrontMatterEntry(frontmatter, 'number-headings-style-level-1') ??\n      parseFrontMatterEntry(frontmatter, 'header-numbering-style-level-1')\n    )\n    const styleLevel1: NumberingStyle = isValidNumberingStyleString(styleLevel1Entry) ? styleLevel1Entry as NumberingStyle : alternativeSettings.styleLevel1\n\n    const styleLevelOtherEntry = String(\n      parseFrontMatterEntry(frontmatter, 'number-headings-style-level-other') ??\n      parseFrontMatterEntry(frontmatter, 'header-numbering-style-level-other')\n    )\n    const styleLevelOther: NumberingStyle = isValidNumberingStyleString(styleLevelOtherEntry) ? styleLevelOtherEntry as NumberingStyle : alternativeSettings.styleLevelOther\n\n    const autoEntry = parseFrontMatterEntry(frontmatter, 'number-headings-auto') ?? parseFrontMatterEntry(frontmatter, 'header-numbering-auto')\n    const auto = isValidFlag(autoEntry) ? autoEntry : alternativeSettings.auto\n\n    return { ...alternativeSettings, skipTopLevel, maxLevel, styleLevel1, styleLevelOther, auto }\n  } else {\n    return alternativeSettings\n  }\n}\n\nfunction settingsToCompactFrontMatterValue (settings: NumberHeadingsPluginSettings): string {\n  const autoPart = settings.auto ? 'auto, ' : ''\n  const firstLevelPart = `first-level ${settings.firstLevel}, `\n  const maxPart = `max ${settings.maxLevel}, `\n  const contentsPart = settings.contents && settings.contents.length > 0 ? `contents ${settings.contents}, ` : ''\n  const skipTopLevelString = settings.skipTopLevel ? '_.' : ''\n  const stylePart = `${skipTopLevelString}${settings.styleLevel1}.${settings.styleLevelOther}${settings.separator}`\n  const startAtPart = settings.startAt !== '' ? `start-at ${settings.startAt}, ` : ''\n  return autoPart + firstLevelPart + maxPart + contentsPart + startAtPart + stylePart\n}\n\nfunction findLineWhichStartsWith (editor: Editor, search: string, afterLine: number): number | undefined {\n  // Find the location of the frontmatter\n  for (let i = afterLine; i < editor.lastLine(); i++) {\n    const lineString = editor.getLine(i)\n    if (lineString.startsWith(search)) {\n      return i\n    }\n  }\n  return undefined\n}\n\nexport const saveSettingsToFrontMatter = (\n  { frontmatter }: CachedMetadata,\n  editor: Editor,\n  settings: NumberHeadingsPluginSettings\n): void => {\n  if (frontmatter !== undefined) {\n    // Front matter already exists, so we'll need to insert the settings into the front matter\n\n    const frontMatterLine = frontmatter.position.start.line\n    const v = settingsToCompactFrontMatterValue(settings)\n    const frontMatterAdditions = `number headings: ${v}\\n`\n\n    if (frontmatter['number headings'] !== undefined) {\n      // Key already present, replace it\n      const keyLine = findLineWhichStartsWith(editor, 'number headings', frontMatterLine)\n      if (keyLine === undefined) throw new Error('Number Headings Plugin: \"number headings\" key exists but not found.')\n      const from: EditorPosition = { line: keyLine, ch: 0 }\n      const to: EditorPosition = { line: keyLine + 1, ch: 0 }\n      editor.replaceRange(frontMatterAdditions, from, to)\n    } else {\n      // Key not present, insert new key\n      const from: EditorPosition = { line: frontMatterLine + 1, ch: 0 }\n      const to: EditorPosition = { line: frontMatterLine + 1, ch: 0 }\n      editor.replaceRange(frontMatterAdditions, from, to)\n    }\n  } else {\n    // No frontmatter found, create frontmatter from scratch\n    const v = settingsToCompactFrontMatterValue(settings)\n    const newFrontMatter = `---\\nnumber headings: ${v}\\n---\\n\\n`\n    const from: EditorPosition = { line: 0, ch: 0 }\n    const to: EditorPosition = { line: 0, ch: 0 }\n    editor.replaceRange(newFrontMatter, from, to)\n    // Front matter does not exist, so we will create it from scratch\n  }\n}\n","import { App, Modal } from 'obsidian'\nimport { ViewInfo } from './activeViewHelpers'\nimport { saveSettingsToFrontMatter } from './frontMatter'\nimport { NumberHeadingsPluginSettings } from './settingsTypes'\n\nexport interface NumberingDoneConfig {\n  message: string\n  preformattedMessage: string\n  saveSettingsCallback: (shouldAddAutoFlag: boolean) => void\n}\n\nclass NumberingDoneModal extends Modal {\n  config: NumberingDoneConfig\n\n  constructor (app: App, config: NumberingDoneConfig) {\n    super(app)\n    this.config = config\n  }\n\n  onOpen (): void {\n    const { contentEl, titleEl } = this\n    titleEl.setText('Number Headings - Successfully Completed')\n\n    contentEl.createEl('div', { text: this.config.message })\n    contentEl.createEl('pre', { text: this.config.preformattedMessage })\n\n    contentEl.createEl('div', { text: \"Do you want to save these settings in the document's front matter?\", cls: 'number-headings-question' })\n\n    const containerForButtons = contentEl.createEl('div', { cls: 'number-headings-button-container' })\n\n    const noButton = containerForButtons.createEl('button', { })\n    noButton.setText('No')\n    noButton.onClickEvent((ev: MouseEvent) => {\n      this.close()\n      return ev\n    })\n\n    const yesButton = containerForButtons.createEl('button', { })\n    yesButton.setText('Yes, save settings in document')\n    yesButton.onClickEvent((ev: MouseEvent) => {\n      this.config.saveSettingsCallback(false)\n      this.close()\n      return ev\n    })\n\n    const yesAndAutoButton = containerForButtons.createEl('button', { })\n    yesAndAutoButton.setText('Yes, save settings in document, and automatically number')\n    yesAndAutoButton.onClickEvent((ev: MouseEvent) => {\n      this.config.saveSettingsCallback(true)\n      this.close()\n      return ev\n    })\n  }\n\n  onClose (): void {\n    const { contentEl, titleEl } = this\n    contentEl.empty()\n    titleEl.empty()\n  }\n}\n\nexport function showNumberingDoneMessage (app: App, settings: NumberHeadingsPluginSettings, viewInfo: ViewInfo): void {\n  const saveSettingsCallback = (shouldAddAutoFlag: boolean): void => {\n    const tweakedSettings = { ...settings }\n    if (shouldAddAutoFlag) tweakedSettings.auto = true\n    saveSettingsToFrontMatter(viewInfo.data, viewInfo.editor, tweakedSettings)\n  }\n  const config: NumberingDoneConfig = {\n    message: `Successfully updated all heading numbers in the document, using the settings below. \n      See settings panel to change how headings are numbered, or use front matter\n      (see settings panel).`,\n    preformattedMessage: `Skip top heading level: ${settings.skipTopLevel}\nFirst heading level: ${settings.firstLevel}\nStart numbering first heading at: ${settings.startAt}\nMaximum heading level: ${settings.maxLevel}\nStyle for level 1 headings: ${settings.styleLevel1}\nStyle for lower level headings (below level 1): ${settings.styleLevelOther}\nSeparator: ${settings.separator}\nTable of Contents Anchor: ${settings.contents}`,\n    saveSettingsCallback\n  }\n\n  const leaf = app.workspace.activeLeaf\n  if (leaf) {\n    new NumberingDoneModal(app, config).open()\n  }\n}\n","import { Editor, EditorChange, EditorRange, HeadingCache } from 'obsidian'\nimport { ViewInfo } from './activeViewHelpers'\nimport { firstNumberingTokenInStyle, makeNumberingString, nextNumberingToken, NumberingToken, startAtOrZerothInStyle } from './numberingTokens'\nimport { doesContentsHaveValue, NumberHeadingsPluginSettings } from './settingsTypes'\nimport { createSupportFlagsFromSettings, findRangeInHeaderString, SupportFlags } from './textProcessing'\n\nconst TOC_LIST_ITEM_BULLET = '-'\n\nfunction makeHeadingHashString (editor: Editor, heading: HeadingCache): string | undefined {\n  const regex = /^\\s{0,4}#+/g\n  const headingLineString = editor.getLine(heading.position.start.line)\n  if (!headingLineString) return undefined\n\n  const matches = headingLineString.match(regex)\n  if (!matches) return undefined\n\n  if (matches.length !== 1) {\n    // eslint-disable-next-line no-console\n    console.log(\"Unexpected heading format: '\" + headingLineString + \"'\")\n    return undefined\n  }\n\n  const match = matches[0]\n  return match.trimLeft()\n}\n\nfunction findHeadingPrefixRange (editor: Editor, heading: HeadingCache, flags: SupportFlags): EditorRange | undefined {\n  const lineNumber = heading.position.start.line\n  const lineText = editor.getLine(lineNumber)\n  return findRangeInHeaderString(lineText, lineNumber, flags)\n}\n\nfunction cleanHeadingTextForToc (htext: string): string {\n  if (htext.contains('^')) {\n    const x = htext.split('^')\n    if (x.length > 1) {\n      return x[0].trim()\n    }\n  }\n  return htext.trim()\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction createTocEntry (h: HeadingCache, settings: NumberHeadingsPluginSettings, initialHeadingLevel: number):string {\n  const text = h.heading\n  const cleanText = cleanHeadingTextForToc(text)\n\n  let bulletIndent = ''\n  const startLevel = initialHeadingLevel\n  for (let i = startLevel; i < h.level; i++) {\n    bulletIndent += '\\t'\n  }\n\n  const entryLink = `[[#${text}|${cleanText}]]`\n\n  return bulletIndent + TOC_LIST_ITEM_BULLET + ' ' + entryLink\n}\n\n// Replace a range, but only if there is a change in text, to prevent poluting the undo stack\nfunction replaceRangeEconomically (editor: Editor, changes: EditorChange[], range: EditorRange, text: string): void {\n  const previousText = editor.getRange(range.from, range.to)\n\n  if (previousText !== text) {\n    changes.push({\n      text: text,\n      from: range.from,\n      to: range.to\n    })\n  }\n}\n\nexport const updateHeadingNumbering = (\n  viewInfo: ViewInfo | undefined,\n  settings: NumberHeadingsPluginSettings\n): void => {\n  if (!viewInfo) return\n  const headings = viewInfo.data.headings ?? []\n  const editor = viewInfo.editor\n  const supportFlags = createSupportFlagsFromSettings(settings.styleLevel1, settings.styleLevelOther)\n\n  let previousLevel = 1\n\n  let numberingStack: NumberingToken[] = [startAtOrZerothInStyle(settings.startAt, settings.styleLevel1)]\n\n  if (settings.firstLevel > 1) {\n    previousLevel = settings.firstLevel\n  } else if (settings.skipTopLevel) {\n    previousLevel = 2\n  }\n\n  const changes: EditorChange[] = []\n\n  for (const heading of headings) {\n    // Update the numbering stack based on the level and previous level\n\n    const level = heading.level\n\n    // Handle skipped & ignored levels.\n    if ((settings.firstLevel > level) || (settings.skipTopLevel && level === 1)) {\n      // Resets the numbering when a level is skipped.\n      // Note: This leaves headings as they are, allowing people to have numbers at the start of\n      // ignored headings.\n\n      numberingStack = [startAtOrZerothInStyle(settings.startAt, settings.styleLevel1)]\n\n      if (settings.firstLevel > 1) {\n        previousLevel = settings.firstLevel\n      } else if (settings.skipTopLevel) {\n        previousLevel = 2\n      }\n      continue\n    }\n\n    // Adjust numbering stack\n    if (level === previousLevel) {\n      const x = numberingStack.pop()\n      if (x !== undefined) {\n        numberingStack.push(nextNumberingToken(x))\n      }\n    } else if (level < previousLevel) {\n      for (let i = previousLevel; i > level; i--) {\n        numberingStack.pop()\n      }\n      const x = numberingStack.pop()\n      if (x !== undefined) {\n        numberingStack.push(nextNumberingToken(x))\n      }\n    } else if (level > previousLevel) {\n      for (let i = previousLevel; i < level; i++) {\n        numberingStack.push(firstNumberingTokenInStyle(settings.styleLevelOther))\n      }\n    }\n\n    // Set the previous level to this level for the next iteration\n    previousLevel = level\n\n    if (level > settings.maxLevel) {\n      // If we are above the max level, just don't number it\n      continue\n    }\n\n    // Find the range to replace, and then do it\n    const prefixRange = findHeadingPrefixRange(editor, heading, supportFlags)\n    if (prefixRange === undefined) return\n    const headingHashString = makeHeadingHashString(editor, heading)\n    if (headingHashString === undefined) return\n    const prefixString = makeNumberingString(numberingStack)\n    replaceRangeEconomically(editor, changes, prefixRange, headingHashString + prefixString + settings.separator + ' ')\n  }\n\n  // Execute the transaction to make all the changes at once\n  if (changes.length > 0) {\n    // eslint-disable-next-line no-console\n    console.log('Number Headings Plugin: Applying headings numbering changes:', changes.length)\n    editor.transaction({\n      changes: changes\n    })\n  }\n}\n\nexport const updateTableOfContents = (\n  viewInfo: ViewInfo | undefined,\n  settings: NumberHeadingsPluginSettings\n): void => {\n  if (!viewInfo) return\n  const headings = viewInfo.data.headings ?? []\n  const editor = viewInfo.editor\n\n  if (!doesContentsHaveValue(settings.contents)) return\n\n  let tocHeading: HeadingCache | undefined\n  let tocBuilder = '\\n'\n  const changes: EditorChange[] = []\n\n  // In case headings start above level 1, we don't want to indent the bullets too much\n  let initialHeadingLevel = 1\n  if (headings.length > 0) {\n    initialHeadingLevel = headings[0].level\n  }\n\n  for (const heading of headings) {\n    // ORDERING: Important to find the TOC heading before skipping skipped headings, since that is for numbering\n\n    // Find the TOC heading\n    if (heading.heading.endsWith(settings.contents)) {\n      tocHeading = heading\n    }\n\n    /* This code lets us skip TOC lines for skipped headings, but doesn't work well with first-level setting\n    if ((settings.skipTopLevel && heading.level === 1) || (heading.level > settings.maxLevel)) {\n      continue\n    }\n    */\n\n    const tocEntry = createTocEntry(heading, settings, initialHeadingLevel)\n    tocBuilder += tocEntry + '\\n'\n  }\n\n  // Insert the generated table of contents\n  if (tocHeading) {\n    const from = {\n      line: tocHeading.position.start.line + 1,\n      ch: 0\n    }\n\n    // Find the end of the TOC section\n    const startingLine = tocHeading.position.start.line + 1\n    let endingLine = startingLine\n    let foundList = false\n    const lastLineInEditor = editor.lastLine()\n    for (; ; endingLine++) {\n      const line = editor.getLine(endingLine)\n      if (line === undefined || endingLine > lastLineInEditor) {\n        // Reached end of file, insert at the start of the TOC section\n        endingLine = startingLine\n        break\n      }\n      const trimmedLineText = line.trimStart()\n      if (foundList) {\n        if (!trimmedLineText.startsWith(TOC_LIST_ITEM_BULLET)) break\n        if (trimmedLineText.startsWith('#')) break\n      } else {\n        if (trimmedLineText.startsWith(TOC_LIST_ITEM_BULLET)) {\n          foundList = true\n        } else if (trimmedLineText.startsWith('#')) {\n          // Reached the next heading without finding existing TOC list, insert at the start of the TOC section\n          endingLine = startingLine\n          break\n        } else {\n          continue\n        }\n      }\n    }\n\n    if (tocBuilder === '\\n') {\n      tocBuilder = ''\n    }\n\n    const to = {\n      line: endingLine,\n      ch: 0\n    }\n    const range = { from, to }\n    replaceRangeEconomically(editor, changes, range, tocBuilder)\n  }\n\n  // Execute the transaction to make all the changes at once\n  if (changes.length > 0) {\n    // eslint-disable-next-line no-console\n    console.log('Number Headings Plugin: Applying table of contents changes:', changes.length)\n    editor.transaction({\n      changes: changes\n    })\n  }\n}\n\nexport const removeHeadingNumbering = (\n  viewInfo: ViewInfo | undefined\n): void => {\n  if (!viewInfo) return\n  const headings = viewInfo.data.headings ?? []\n  const editor = viewInfo.editor\n\n  const changes: EditorChange[] = []\n\n  for (const heading of headings) {\n    const prefixRange = findHeadingPrefixRange(editor, heading, { alphabet: true, roman: true })\n    if (prefixRange === undefined) return\n    const headingHashString = makeHeadingHashString(editor, heading)\n    if (headingHashString === undefined) return\n    replaceRangeEconomically(editor, changes, prefixRange, headingHashString + ' ')\n  }\n\n  if (changes.length > 0) {\n    editor.transaction({\n      changes: changes\n    })\n  }\n}\n","import { App, Plugin, PluginSettingTab, Setting } from 'obsidian'\r\nimport { getViewInfo, isViewActive } from './activeViewHelpers'\r\nimport { getFrontMatterSettingsOrAlternative, saveSettingsToFrontMatter } from './frontMatter'\r\nimport { showNumberingDoneMessage } from './messages'\r\nimport { removeHeadingNumbering, updateHeadingNumbering, updateTableOfContents } from './numbering'\r\nimport { NumberingStyle } from './numberingTokens'\r\nimport { DEFAULT_SETTINGS, NumberHeadingsPluginSettings } from './settingsTypes'\r\n\r\nclass NumberHeadingsPluginSettingTab extends PluginSettingTab {\r\n  plugin: NumberHeadingsPlugin\r\n\r\n  constructor (app: App, plugin: NumberHeadingsPlugin) {\r\n    super(app, plugin)\r\n    this.plugin = plugin\r\n  }\r\n\r\n  display (): void {\r\n    const { containerEl } = this\r\n\r\n    containerEl.empty()\r\n\r\n    containerEl.createEl('h2', { text: 'Number Headings - Settings' })\r\n\r\n    containerEl.createEl('div', { text: 'To add numbering to your document, bring up the command window (on Mac, type CMD+P), and then type \"Number Headings\" to see a list of available commands.' })\r\n\r\n    containerEl.createEl('br', {})\r\n\r\n    containerEl.createEl('div', { text: 'If the document has front matter defined with the below settings, the project-wide settings defined on this screen will be ignored. You can define front matter like this:' })\r\n\r\n    containerEl.createEl('pre', {\r\n      text: `    ---\r\n    alias:\r\n    - Example Alias\r\n    tags:\r\n    - example-tag\r\n    number headings: first-level 1, start-at 2, max 6, 1.1, auto, contents ^toc\r\n    ---`\r\n    })\r\n\r\n    containerEl.createEl('div', {\r\n      text: `\r\n      The 'number headings' front matter key is used to store numbering settings specific to the file. There are four possible options\r\n      in the value to the right of the colon, separated by commas.\r\n    `\r\n    })\r\n\r\n    const ul = containerEl.createEl('ul', {})\r\n\r\n    const li0 = ul.createEl('li', { })\r\n    li0.createEl('b', { text: 'Automatic numbering' })\r\n    li0.createEl('span', { text: ': If \\'auto\\' appears, the document will be automatically numbered.' })\r\n\r\n    const li1 = ul.createEl('li', { })\r\n    li1.createEl('b', { text: 'First level to number' })\r\n    li1.createEl('span', { text: ': If \\'first-level 2\\' appears, the numbering will start at the second level' })\r\n\r\n    const li2 = ul.createEl('li', { })\r\n    li2.createEl('b', { text: 'Start numbering first heading at' })\r\n    li2.createEl('span', { text: ': If \\'start-at C\\' appears, the numbering of the first level will start at C, instead of A' })\r\n\r\n    const li3 = ul.createEl('li', { })\r\n    li3.createEl('b', { text: 'Maximum level to number' })\r\n    li3.createEl('span', { text: ': If \\'max 6\\' appears, the headings above level 6 will be skipped.' })\r\n\r\n    const li4 = ul.createEl('li', { })\r\n    li4.createEl('b', { text: 'Table of contents anchor' })\r\n    li4.createEl('span', { text: ': If \\'contents ^toc\\' appears, the heading that ends with the anchor ^toc will have a table of contents inserted beneath it.' })\r\n\r\n    const li5 = ul.createEl('li', { })\r\n    li5.createEl('b', { text: 'Numbering style' })\r\n    li5.createEl('span', {\r\n      text: `:\r\n      A style text like '1.1', 'A.1', or '_.1.1' tells the plugin how to format the headings.\r\n      If a style string ends with '.' (a dot), ':' (a colon), '-' (a dash), '—' (an emdash), or ')' (a right parenthesis), the heading numbers will be separated from the heading title\r\n      with that symbol.`\r\n    })\r\n\r\n    const ul3 = li5.createEl('ul', {})\r\n    ul3.createEl('li', {\r\n      text: `      \r\n      For example, '1.1' means both top level and other headings will be numbered starting from '1'.\r\n    `\r\n    })\r\n    ul3.createEl('li', {\r\n      text: `      \r\n      For example, 'A.1' means top level headings will be numbered starting from 'A'.\r\n    `\r\n    })\r\n    ul3.createEl('li', {\r\n      text: `      \r\n      For example, '_.A.1' means top level headings will NOT be numbered, but the next levels will be numbered with letters and numbers.\r\n    `\r\n    })\r\n    ul3.createEl('li', {\r\n      text: `      \r\n      For example, '1.1:' means headings will look like '## 2.4: Example Heading'\r\n    `\r\n    })\r\n    ul3.createEl('li', {\r\n      text: `      \r\n      For example, 'A.1-' means headings will look like '## B.5- Example Heading'\r\n    `\r\n    })\r\n    ul3.createEl('li', {\r\n      text: `      \r\n      For example, 'I.A —' means headings will look like '## IV.A — Example Heading' (with Roman numerals)\r\n    `\r\n    })\r\n\r\n    new Setting(containerEl)\r\n      .setName('Skip top heading level')\r\n      .setDesc('If selected, numbering will not be applied to the top heading level.')\r\n      .addToggle(toggle => toggle\r\n        .setValue(this.plugin.settings.skipTopLevel)\r\n        .setTooltip('Skip top heading level')\r\n        .onChange(async (value) => {\r\n          this.plugin.settings.skipTopLevel = value\r\n          await this.plugin.saveSettings()\r\n        }))\r\n\r\n    new Setting(containerEl)\r\n      .setName('First heading level')\r\n      .setDesc('First heading level to number.')\r\n      .addSlider(slider => slider\r\n        .setLimits(1, 6, 1)\r\n        .setValue(this.plugin.settings.firstLevel)\r\n        .setDynamicTooltip()\r\n        .onChange(async (value) => {\r\n          this.plugin.settings.firstLevel = value\r\n          await this.plugin.saveSettings()\r\n        }))\r\n\r\n    new Setting(containerEl)\r\n      .setName('Start numbering at')\r\n      .setDesc('Start numbering the first heading level from this value.')\r\n      .addText(text => text\r\n        .setValue(this.plugin.settings.startAt)\r\n        .onChange(async (value) => {\r\n          this.plugin.settings.startAt = value\r\n          await this.plugin.saveSettings()\r\n        }))\r\n\r\n    new Setting(containerEl)\r\n      .setName('Maximum heading level')\r\n      .setDesc('Maximum heading level to number.')\r\n      .addSlider(slider => slider\r\n        .setLimits(1, 6, 1)\r\n        .setValue(this.plugin.settings.maxLevel)\r\n        .setDynamicTooltip()\r\n        .onChange(async (value) => {\r\n          this.plugin.settings.maxLevel = value\r\n          await this.plugin.saveSettings()\r\n        }))\r\n\r\n    new Setting(containerEl)\r\n      .setName('Style for level 1 headings')\r\n      .setDesc('Defines the numbering style for level one headings. Valid values are 1 (for numbers) or A (for capital letters) or I (for Roman numerals).')\r\n      .addText(text => text\r\n        .setValue(this.plugin.settings.styleLevel1)\r\n        .onChange(async (value) => {\r\n          this.plugin.settings.styleLevel1 = value as NumberingStyle\r\n          await this.plugin.saveSettings()\r\n        }))\r\n\r\n    new Setting(containerEl)\r\n      .setName('Style for lower level headings (below level 1)')\r\n      .setDesc('Defines the numbering style for headings below level one. Valid values are 1 (for numbers) or A (for capital letters) or I (for Roman numerals).')\r\n      .addText(text => text\r\n        .setValue(this.plugin.settings.styleLevelOther)\r\n        .onChange(async (value) => {\r\n          this.plugin.settings.styleLevelOther = value as NumberingStyle\r\n          await this.plugin.saveSettings()\r\n        }))\r\n\r\n    new Setting(containerEl)\r\n      .setName('Automatic numbering')\r\n      .setDesc('Turns on automatic numbering of documents.')\r\n      .addToggle(toggle => toggle\r\n        .setValue(this.plugin.settings.auto)\r\n        .setTooltip('Turn on automatic numbering')\r\n        .onChange(async (value) => {\r\n          this.plugin.settings.auto = value\r\n          await this.plugin.saveSettings()\r\n        }))\r\n\r\n    new Setting(containerEl)\r\n      .setName('Separator style')\r\n      .setDesc('Defines the separator style between the heading number and the heading text. Valid values are : (colon) or . (dot) or - (dash) or — (emdash) or ) (a right parenthesis). You can also leave it blank for no separator, or have a space before the separator.')\r\n      .addText(text => text\r\n        .setValue(this.plugin.settings.separator)\r\n        .onChange(async (value) => {\r\n          this.plugin.settings.separator = value\r\n          await this.plugin.saveSettings()\r\n        }))\r\n\r\n    new Setting(containerEl)\r\n      .setName('Table of Contents Anchor')\r\n      .setDesc('Anchor which labels the header where a table of contents should be inserted. The anchor should be added at the end of a header. For example, ^toc.')\r\n      .addText(text => text\r\n        .setValue(this.plugin.settings.contents)\r\n        .onChange(async (value) => {\r\n          this.plugin.settings.contents = value\r\n          await this.plugin.saveSettings()\r\n        }))\r\n  }\r\n}\r\n\r\nexport default class NumberHeadingsPlugin extends Plugin {\r\n  settings!: NumberHeadingsPluginSettings\r\n\r\n  async onload (): Promise<void> {\r\n    // eslint-disable-next-line no-console\r\n    console.info('Loading Number Headings Plugin, version ' + this.manifest.version)\r\n\r\n    await this.loadSettings()\r\n\r\n    this.addCommand({\r\n      id: 'number-headings-with-options',\r\n      name: 'Number all headings in document (and show options)',\r\n      checkCallback: (checking: boolean) => {\r\n        if (checking) return isViewActive(this.app)\r\n\r\n        const viewInfo = getViewInfo(this.app)\r\n        if (viewInfo) {\r\n          const settings = getFrontMatterSettingsOrAlternative(viewInfo.data, this.settings)\r\n          updateHeadingNumbering(viewInfo, settings)\r\n          setTimeout(() => {\r\n            // HACK: This must happen after a timeout so that there is time for the editor transaction to complete\r\n            const postNumberingViewInfo = getViewInfo(this.app)\r\n            updateTableOfContents(postNumberingViewInfo, settings)\r\n          }, 3000)\r\n\r\n          showNumberingDoneMessage(this.app, settings, viewInfo)\r\n        }\r\n\r\n        return false\r\n      }\r\n    })\r\n\r\n    this.addCommand({\r\n      id: 'number-headings',\r\n      name: 'Number all headings in document',\r\n      checkCallback: (checking: boolean) => {\r\n        if (checking) return isViewActive(this.app)\r\n\r\n        const viewInfo = getViewInfo(this.app)\r\n        if (viewInfo) {\r\n          const settings = getFrontMatterSettingsOrAlternative(viewInfo.data, this.settings)\r\n          updateHeadingNumbering(viewInfo, settings)\r\n          setTimeout(() => {\r\n            // HACK: This must happen after a timeout so that there is time for the editor transaction to complete\r\n            const postNumberingViewInfo = getViewInfo(this.app)\r\n            updateTableOfContents(postNumberingViewInfo, settings)\r\n          }, 3000)\r\n\r\n          // NOTE: The line below is intentionally commented out, since this command is the same as\r\n          //       the above command, except for this line\r\n          // showNumberingDoneMessage(this.app, settings, viewInfo)\r\n        }\r\n\r\n        return false\r\n      }\r\n    })\r\n\r\n    this.addCommand({\r\n      id: 'remove-number-headings',\r\n      name: 'Remove numbering from all headings in document',\r\n      checkCallback: (checking: boolean) => {\r\n        if (checking) return isViewActive(this.app)\r\n\r\n        const viewInfo = getViewInfo(this.app)\r\n        removeHeadingNumbering(viewInfo)\r\n\r\n        return true\r\n      }\r\n    })\r\n\r\n    this.addCommand({\r\n      id: 'save-settings-to-front-matter',\r\n      name: 'Save settings to front matter',\r\n      checkCallback: (checking: boolean) => {\r\n        if (checking) return isViewActive(this.app)\r\n\r\n        const viewInfo = getViewInfo(this.app)\r\n        if (viewInfo) {\r\n          const settings = getFrontMatterSettingsOrAlternative(viewInfo.data, this.settings)\r\n          saveSettingsToFrontMatter(viewInfo.data, viewInfo.editor, settings)\r\n        }\r\n\r\n        return false\r\n      }\r\n    })\r\n\r\n    this.addSettingTab(new NumberHeadingsPluginSettingTab(this.app, this))\r\n\r\n    this.registerInterval(window.setInterval(() => {\r\n      const viewInfo = getViewInfo(this.app)\r\n      if (viewInfo) {\r\n        const settings = getFrontMatterSettingsOrAlternative(viewInfo.data, this.settings)\r\n\r\n        if (settings.auto) {\r\n          updateHeadingNumbering(viewInfo, settings)\r\n          setTimeout(() => {\r\n            // HACK: This must happen after a timeout so that there is time for the editor transaction to complete\r\n            const postNumberingViewInfo = getViewInfo(this.app)\r\n            updateTableOfContents(postNumberingViewInfo, settings)\r\n          }, 3000)\r\n          // eslint-disable-next-line no-console\r\n          console.log('Number Headings Plugin: Automatically numbered document')\r\n        }\r\n      }\r\n    }, 10 * 1000))\r\n  }\r\n\r\n  async loadSettings (): Promise<void> {\r\n    this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData())\r\n  }\r\n\r\n  async saveSettings (): Promise<void> {\r\n    await this.saveData(this.settings)\r\n  }\r\n}\r\n"],"names":["MarkdownView","romanize","deromanize","parseFrontMatterEntry","Modal","PluginSettingTab","Setting","Plugin"],"mappings":";;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAuDA;AACO,SAAS,SAAS,CAAC,OAAO,EAAE,UAAU,EAAE,CAAC,EAAE,SAAS,EAAE;AAC7D,IAAI,SAAS,KAAK,CAAC,KAAK,EAAE,EAAE,OAAO,KAAK,YAAY,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC,CAAC,UAAU,OAAO,EAAE,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE;AAChH,IAAI,OAAO,KAAK,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,EAAE,UAAU,OAAO,EAAE,MAAM,EAAE;AAC/D,QAAQ,SAAS,SAAS,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE;AACnG,QAAQ,SAAS,QAAQ,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE;AACtG,QAAQ,SAAS,IAAI,CAAC,MAAM,EAAE,EAAE,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC,EAAE;AACtH,QAAQ,IAAI,CAAC,CAAC,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,OAAO,EAAE,UAAU,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9E,KAAK,CAAC,CAAC;AACP;;AC3EA,SAAS,aAAa,CAAE,GAAQ,EAAA;IAC9B,MAAM,UAAU,GAAG,GAAG,CAAC,SAAS,CAAC,mBAAmB,CAACA,qBAAY,CAAC,CAAA;AAClE,IAAA,OAAO,UAAU,KAAV,IAAA,IAAA,UAAU,cAAV,UAAU,GAAI,SAAS,CAAA;AAChC,CAAC;AAEK,SAAU,YAAY,CAAE,GAAQ,EAAA;AACpC,IAAA,MAAM,UAAU,GAAG,aAAa,CAAC,GAAG,CAAC,CAAA;AACrC,IAAA,IAAI,UAAU,IAAI,UAAU,CAAC,IAAI;AAAE,QAAA,OAAO,IAAI,CAAA;AAC9C,IAAA,OAAO,KAAK,CAAA;AACd,CAAC;AAED,SAAS,eAAe,CAAE,GAAQ,EAAA;AAChC,IAAA,MAAM,UAAU,GAAG,aAAa,CAAC,GAAG,CAAC,CAAA;AACrC,IAAA,IAAI,UAAU,IAAI,UAAU,CAAC,IAAI,EAAE;AACjC,QAAA,MAAM,IAAI,GAAG,GAAG,CAAC,aAAa,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,CAAA;AAClE,QAAA,OAAO,IAAI,CAAA;AACZ,KAAA;AACD,IAAA,OAAO,SAAS,CAAA;AAClB,CAAC;AAQK,SAAU,WAAW,CAAE,GAAQ,EAAA;AACnC,IAAA,MAAM,UAAU,GAAG,aAAa,CAAC,GAAG,CAAC,CAAA;AACrC,IAAA,MAAM,IAAI,GAAG,eAAe,CAAC,GAAG,CAAC,CAAA;AACjC,IAAA,MAAM,MAAM,GAAG,UAAU,GAAG,UAAU,CAAC,MAAM,GAAG,SAAS,CAAA;AAEzD,IAAA,IAAI,UAAU,IAAI,IAAI,IAAI,MAAM,EAAE;QAChC,OAAO;YACL,UAAU,EAAE,IAAI,EAAE,MAAM;SACzB,CAAA;AACF,KAAA;AAED,IAAA,OAAO,SAAS,CAAA;AAClB;;ACxCA,MAAM,SAAS,GAAG;AAClB,EAAE,CAAC,EAAE,IAAI;AACT,EAAE,EAAE,EAAE,GAAG;AACT,EAAE,CAAC,EAAE,GAAG;AACR,EAAE,EAAE,EAAE,GAAG;AACT,EAAE,CAAC,EAAE,GAAG;AACR,EAAE,EAAE,EAAE,EAAE;AACR,EAAE,CAAC,EAAE,EAAE;AACP,EAAE,EAAE,EAAE,EAAE;AACR,EAAE,CAAC,EAAE,EAAE;AACP,EAAE,EAAE,EAAE,CAAC;AACP,EAAE,CAAC,EAAE,CAAC;AACN,EAAE,EAAE,EAAE,CAAC;AACP,EAAE,CAAC,EAAE,CAAC;AACN,EAAC;AACD;AACA,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,EAAC;AACvC,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,SAAS,EAAC;AAC5C,MAAM,YAAY;AAClB,EAAE,qOAAoO;AACtO;AACA,MAAM,QAAQ,GAAG,CAAC,OAAO,KAAK;AAC9B,EAAE;AACF,IAAI,OAAO,IAAI,CAAC;AAChB,IAAI,OAAO,OAAO,KAAK,QAAQ;AAC/B,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,OAAO;AACnC,IAAI;AACJ,IAAI,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC;AACnD,GAAG;AACH,EAAE,IAAI,OAAO,IAAI,IAAI,EAAE;AACvB,IAAI,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC;AACnE,GAAG;AACH,EAAE,IAAI,KAAK,GAAG,GAAE;AAChB,EAAE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AAC5C,IAAI,OAAO,OAAO,IAAI,WAAW,CAAC,CAAC,CAAC,EAAE;AACtC,MAAM,OAAO,IAAI,WAAW,CAAC,CAAC,EAAC;AAC/B,MAAM,KAAK,IAAI,QAAQ,CAAC,CAAC,EAAC;AAC1B,KAAK;AACL,GAAG;AACH,EAAE,OAAO,KAAK;AACd,EAAC;AACD;AACA,MAAM,UAAU,GAAG,CAAC,QAAQ,KAAK;AACjC,EAAE,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE;AACpC,IAAI,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC;AACxC,GAAG;AACH,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;AACpC,IAAI,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC;AAC1D,GAAG;AACH,EAAE,IAAI,WAAW,GAAG,QAAQ,CAAC,WAAW,GAAE;AAC1C,EAAE,IAAI,MAAM,GAAG,EAAC;AAChB,EAAE,IAAI,SAAS,GAAG,WAAW,CAAC,OAAM;AACpC,EAAE,OAAO,SAAS,EAAE,EAAE;AACtB,IAAI,IAAI,UAAU,GAAG,SAAS,CAAC,WAAW,CAAC,SAAS,CAAC,EAAC;AACtD,IAAI,IAAI,UAAU,GAAG,SAAS,CAAC,WAAW,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,EAAE;AAC5D,MAAM,MAAM,IAAI,WAAU;AAC1B,KAAK,MAAM;AACX,MAAM,MAAM,IAAI,WAAU;AAC1B,KAAK;AACL,GAAG;AACH,EAAE,OAAO,MAAM;AACf,EAAC;AACD;AACA,IAAA,MAAc,GAAG;AACjB,EAAE,UAAU;AACZ,EAAE,QAAQ;AACV,EAAE,QAAQ;AACV,EAAE,WAAW;AACb;;AClDA;AACM,SAAU,iCAAiC,CAAE,CAAS,EAAA;IAC1D,MAAM,KAAK,GAAG,UAAU,CAAA;AACxB,IAAA,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;AACtB,CAAC;AAED;AACM,SAAU,mCAAmC,CAAE,CAAS,EAAA;IAC5D,MAAM,KAAK,GAAG,SAAS,CAAA;AACvB,IAAA,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;AACtB,CAAC;AAED;AACM,SAAU,gCAAgC,CAAE,CAAS,EAAA;AACzD,IAAA,MAAM,KAAK,GAAG,eAAe,CAAA;AAC7B,IAAA,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;AACtB,CAAC;AAED,SAAS,uBAAuB,CAAE,CAAiB,EAAA;IACjD,QAAQ,CAAC,CAAC,KAAK;AACb,QAAA,KAAK,GAAG;AACN,YAAA,OAAO,CAAC,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAA;AAC3B,QAAA,KAAK,GAAG;YACN,OAAO,CAAC,CAAC,KAAK,CAAA;AAChB,QAAA,KAAK,GAAG;YACN,OAAO,CAAC,CAAC,KAAK,CAAA;AACjB,KAAA;AACH,CAAC;AAEK,SAAU,2BAA2B,CAAE,KAAqB,EAAA;AAChE,IAAA,QAAQ,KAAK;AACX,QAAA,KAAK,GAAG;YACN,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,CAAA;AACjC,QAAA,KAAK,GAAG;YACN,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,CAAA;AACnC,QAAA,KAAK,GAAG;YACN,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,CAAA;AACpC,KAAA;AACH,CAAC;AAEK,SAAU,0BAA0B,CAAE,KAAqB,EAAA;AAC/D,IAAA,QAAQ,KAAK;AACX,QAAA,KAAK,GAAG;YACN,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,CAAA;AACjC,QAAA,KAAK,GAAG;YACN,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,CAAA;AACnC,QAAA,KAAK,GAAG;YACN,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,CAAA;AACpC,KAAA;AACH,CAAC;AAEK,SAAU,kBAAkB,CAAE,CAAiB,EAAA;IACnD,QAAQ,CAAC,CAAC,KAAK;AACb,QAAA,KAAK,GAAG;AACN,YAAA,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,GAAG,CAAC,EAAE,CAAA;AAC3C,QAAA,KAAK,GAAG;AACN,YAAA,IAAI,CAAC,CAAC,KAAK,KAAK,GAAG;gBAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,CAAA;;gBACjD,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAA;AACnF,QAAA,KAAK,GAAG;AACN,YAAA,IAAI,CAAC,CAAC,KAAK,KAAK,GAAG;gBAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,CAAA;;AACjD,gBAAA,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAEC,eAAQ,CAACC,iBAAU,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,CAAA;AACvE,KAAA;AACH,CAAC;AAEK,SAAU,sBAAsB,CAAE,CAAiB,EAAA;IACvD,QAAQ,CAAC,CAAC,KAAK;AACb,QAAA,KAAK,GAAG;AACN,YAAA,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,GAAG,CAAC,EAAE,CAAA;AAC3C,QAAA,KAAK,GAAG;AACN,YAAA,IAAI,CAAC,CAAC,KAAK,KAAK,GAAG;gBAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,CAAA;;gBACjD,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAA;AACnF,QAAA,KAAK,GAAG;AACN,YAAA,IAAI,CAAC,CAAC,KAAK,KAAK,GAAG;gBAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,CAAA;;AACjD,gBAAA,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAED,eAAQ,CAACC,iBAAU,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,CAAA;AACvE,KAAA;AACH,CAAC;AAEK,SAAU,mBAAmB,CAAE,cAAgC,EAAA;IACnE,IAAI,eAAe,GAAG,EAAE,CAAA;AAExB,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,cAAc,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QAC9C,IAAI,CAAC,KAAK,CAAC,EAAE;YACX,eAAe,IAAI,GAAG,CAAA;AACvB,SAAA;AAAM,aAAA;YACL,eAAe,IAAI,GAAG,CAAA;AACvB,SAAA;QACD,eAAe,IAAI,uBAAuB,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAA;AAC9D,KAAA;AAED,IAAA,OAAO,eAAe,CAAA;AACxB,CAAC;AAEe,SAAA,sBAAsB,CAAE,oBAA4B,EAAE,KAAsB,EAAA;IAC1F,IAAI,oBAAoB,KAAK,EAAE;AAAE,QAAA,OAAO,2BAA2B,CAAC,KAAK,CAAC,CAAA;AAE1E,IAAA,IAAI,8BAA8C,CAAA;AAElD,IAAA,QAAQ,KAAK;AACX,QAAA,KAAK,GAAG;AACN,YAAA,IAAI,CAAC,iCAAiC,CAAC,oBAAoB,CAAC;AAAE,gBAAA,OAAO,2BAA2B,CAAC,KAAK,CAAC,CAAA;AAEvG,YAAA,8BAA8B,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,QAAQ,CAAC,oBAAoB,CAAC,EAAE,CAAA;YACtF,MAAK;AACP,QAAA,KAAK,GAAG;AACN,YAAA,IAAI,CAAC,mCAAmC,CAAC,oBAAoB,CAAC;AAAE,gBAAA,OAAO,2BAA2B,CAAC,KAAK,CAAC,CAAA;YAEzG,8BAA8B,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,oBAAoB,EAAE,CAAA;YAC5E,MAAK;AACP,QAAA,KAAK,GAAG;AACN,YAAA,IAAI,CAAC,gCAAgC,CAAC,oBAAoB,CAAC;AAAE,gBAAA,OAAO,2BAA2B,CAAC,KAAK,CAAC,CAAA;YACtG,8BAA8B,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,oBAAoB,EAAE,CAAA;YAC5E,MAAK;AACR,KAAA;;AAGD,IAAA,OAAO,sBAAsB,CAAC,8BAA8B,CAAC,CAAA;AAC/D;;ACxHO,MAAM,gBAAgB,GAA2C;AACtE,IAAA,YAAY,EAAE,KAAK;AACnB,IAAA,UAAU,EAAE,CAAC;AACb,IAAA,QAAQ,EAAE,CAAC;AACX,IAAA,WAAW,EAAE,GAAG;AAChB,IAAA,eAAe,EAAE,GAAG;AACpB,IAAA,IAAI,EAAE,KAAK;AACX,IAAA,SAAS,EAAE,EAAE;AACb,IAAA,QAAQ,EAAE,EAAE;AACZ,IAAA,OAAO,EAAE,EAAE;CACZ,CAAA;AAEK,SAAU,2BAA2B,CAAE,CAAS,EAAA;IACpD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG;AAAE,QAAA,OAAO,IAAI,CAAA;AACpD,IAAA,OAAO,KAAK,CAAA;AACd,CAAC;AAEK,SAAU,2BAA2B,CAAE,CAAS,EAAA;AACpD,IAAA,IAAI,CAAC,KAAK,EAAE,IAAI,iCAAiC,CAAC,CAAC,CAAC,IAAI,mCAAmC,CAAC,CAAC,CAAC,IAAI,gCAAgC,CAAC,CAAC,CAAC;AAAE,QAAA,OAAO,IAAI,CAAA;AAClJ,IAAA,OAAO,KAAK,CAAA;AACd,CAAC;AAEK,SAAU,WAAW,CAAE,CAAU,EAAA;AACrC,IAAA,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,KAAK;AAAE,QAAA,OAAO,IAAI,CAAA;AAC1C,IAAA,OAAO,KAAK,CAAA;AACd,CAAC;AAEK,SAAU,sBAAsB,CAAE,CAAU,EAAA;IAChD,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;AAAE,QAAA,OAAO,IAAI,CAAA;AAC1D,IAAA,OAAO,KAAK,CAAA;AACd,CAAC;AAEK,SAAU,gBAAgB,CAAE,CAAU,EAAA;IAC1C,OAAO,OAAO,CAAC,KAAK,QAAQ;SAExB,CAAC,KAAK,EAAE;AACR,YAAA,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI;AACvB,YAAA,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI;AACvB,YAAA,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI;AACvB,YAAA,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI;AACvB,YAAA,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,CACxB,CAAA;AACL,CAAC;AAEK,SAAU,eAAe,CAAE,CAAU,EAAA;AACzC,IAAA,IAAI,OAAO,CAAC,KAAK,QAAQ,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;AAAE,QAAA,OAAO,IAAI,CAAA;AACzE,IAAA,OAAO,KAAK,CAAA;AACd,CAAC;AAEK,SAAU,qBAAqB,CAAE,CAAS,EAAA;IAC9C,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC;AAAE,QAAA,OAAO,IAAI,CAAA;AAClD,IAAA,OAAO,KAAK,CAAA;AACd;;ACzDgB,SAAA,8BAA8B,CAAE,WAAmB,EAAE,eAAuB,EAAA;IAC1F,OAAO;AACL,QAAA,QAAQ,EAAE,WAAW,KAAK,GAAG,IAAI,eAAe,KAAK,GAAG;AACxD,QAAA,KAAK,EAAE,WAAW,KAAK,GAAG,IAAI,eAAe,KAAK,GAAG;KACtD,CAAA;AACH,CAAC;AAED,SAAS,uBAAuB,CAAE,KAAmB,EAAA;AACnD,IAAA,IAAI,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,KAAK,EAAE;;AAEjC,QAAA,OAAO,2FAA2F,CAAA;AACnG,KAAA;SAAM,IAAI,CAAC,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,KAAK,EAAE;;AAEzC,QAAA,OAAO,6EAA6E,CAAA;AACrF,KAAA;SAAM,IAAI,KAAK,CAAC,QAAQ,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE;;AAEzC,QAAA,OAAO,mEAAmE,CAAA;AAC3E,KAAA;SAAM,IAAI,CAAC,KAAK,CAAC,QAAQ,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE;;AAE1C,QAAA,OAAO,qDAAqD,CAAA;AAC7D,KAAA;AAED,IAAA,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAA;AAC5D,CAAC;SAEe,uBAAuB,CAAE,QAAgB,EAAE,UAAkB,EAAE,KAAmB,EAAA;AAChG,IAAA,MAAM,KAAK,GAAG,uBAAuB,CAAC,KAAK,CAAC,CAAA;AAE5C,IAAA,IAAI,CAAC,QAAQ;AAAE,QAAA,OAAO,SAAS,CAAA;IAE/B,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;AAErC,IAAA,IAAI,OAAO,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;;QAEnC,OAAO,CAAC,GAAG,CAAC,8BAA8B,GAAG,QAAQ,GAAG,GAAG,CAAC,CAAA;AAC5D,QAAA,OAAO,SAAS,CAAA;AACjB,KAAA;AAED,IAAA,MAAM,KAAK,GAAG,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,CAAA;AAEvC,IAAA,MAAM,IAAI,GAAG;AACX,QAAA,IAAI,EAAE,UAAU;AAChB,QAAA,EAAE,EAAE,CAAC;KACN,CAAA;AACD,IAAA,MAAM,EAAE,GAAG;AACT,QAAA,IAAI,EAAE,UAAU;QAChB,EAAE,EAAE,KAAK,CAAC,MAAM;KACjB,CAAA;AAED,IAAA,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,CAAA;AACrB,CAAC;AAEe,SAAA,uCAAuC,CAAE,IAAY,EAAE,QAAsC,EAAA;;IAE3G,IAAI,oBAAoB,GAAG,IAAI,CAAA;IAC/B,MAAM,yBAAyB,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;AAChD,IAAA,IAAI,gBAAgB,CAAC,yBAAyB,CAAC,EAAE;AAC/C,QAAA,QAAQ,CAAC,SAAS,GAAG,yBAAyB,CAAA;QAC9C,oBAAoB,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;AACzC,KAAA;AAAM,SAAA;QACL,MAAM,yBAAyB,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;AAChD,QAAA,IAAI,gBAAgB,CAAC,yBAAyB,CAAC,EAAE;AAC/C,YAAA,QAAQ,CAAC,SAAS,GAAG,yBAAyB,CAAA;YAC9C,oBAAoB,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;AACzC,SAAA;AAAM,aAAA;AACL,YAAA,QAAQ,CAAC,SAAS,GAAG,EAAE,CAAA;AACxB,SAAA;AACF,KAAA;;IAGD,MAAM,WAAW,GAAG,oBAAoB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;IACnD,IAAI,uBAAuB,GAAG,CAAC,CAAA;;AAG/B,IAAA,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE;;AAEpD,QAAA,QAAQ,CAAC,YAAY,GAAG,IAAI,CAAA;QAC5B,uBAAuB,GAAG,CAAC,CAAA;AAC5B,KAAA;AAAM,SAAA;AACL,QAAA,QAAQ,CAAC,YAAY,GAAG,KAAK,CAAA;AAC9B,KAAA;AAED,IAAA,IAAI,WAAW,CAAC,MAAM,GAAG,uBAAuB,IAAI,CAAC,EAAE;AACrD,QAAA,MAAM,WAAW,GAAG,WAAW,CAAC,uBAAuB,CAAC,CAAA;AACxD,QAAA,IAAI,2BAA2B,CAAC,WAAW,CAAC,EAAE;AAC5C,YAAA,QAAQ,CAAC,WAAW,GAAG,WAA6B,CAAA;AACrD,SAAA;QACD,MAAM,eAAe,GAAG,WAAW,CAAC,uBAAuB,GAAG,CAAC,CAAC,CAAA;AAChE,QAAA,IAAI,2BAA2B,CAAC,eAAe,CAAC,EAAE;AAChD,YAAA,QAAQ,CAAC,eAAe,GAAG,eAAiC,CAAA;AAC7D,SAAA;AACF,KAAA;AAED,IAAA,OAAO,QAAQ,CAAA;AACjB;;AClGA,MAAM,aAAa,GAAG,MAAM,CAAA;AAC5B,MAAM,oBAAoB,GAAG,aAAa,CAAA;AAC1C,MAAM,kBAAkB,GAAG,KAAK,CAAA;AAChC,MAAM,iBAAiB,GAAG,UAAU,CAAA;AACpC,MAAM,iBAAiB,GAAG,UAAU,CAAA;AAEpC,SAAS,+BAA+B,CAAE,EAAoB,EAAA;IAC5D,MAAM,KAAK,GAAGC,8BAAqB,CAAC,EAAE,EAAE,iBAAiB,CAAC,CAAA;AAC1D,IAAA,IAAI,KAAK,EAAE;AACT,QAAA,MAAM,WAAW,GAAG,MAAM,CAAC,KAAK,CAAC,CAAA;QACjC,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;AACpC,QAAA,IAAI,QAAQ,GAAA,MAAA,CAAA,MAAA,CAAA,EAAA,EAAsC,gBAAgB,CAAE,CAAA;AAEpE,QAAA,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;AACxB,YAAA,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,EAAE,CAAA;AAC/B,YAAA,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC;gBAAE,SAAQ;YAEtC,IAAI,WAAW,KAAK,aAAa,EAAE;;AAEjC,gBAAA,QAAQ,CAAC,IAAI,GAAG,IAAI,CAAA;AACrB,aAAA;AAAM,iBAAA,IAAI,WAAW,CAAC,UAAU,CAAC,oBAAoB,CAAC,EAAE;;AAEvD,gBAAA,MAAM,OAAO,GAAG,WAAW,CAAC,SAAS,CAAC,oBAAoB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;AACtE,gBAAA,MAAM,CAAC,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAA;AAC3B,gBAAA,IAAI,sBAAsB,CAAC,CAAC,CAAC,EAAE;AAC7B,oBAAA,QAAQ,CAAC,UAAU,GAAG,CAAC,CAAA;AACxB,iBAAA;AACF,aAAA;AAAM,iBAAA,IAAI,WAAW,CAAC,UAAU,CAAC,kBAAkB,CAAC,EAAE;;AAErD,gBAAA,MAAM,OAAO,GAAG,WAAW,CAAC,SAAS,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;AACpE,gBAAA,MAAM,CAAC,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAA;AAC3B,gBAAA,IAAI,sBAAsB,CAAC,CAAC,CAAC,EAAE;AAC7B,oBAAA,QAAQ,CAAC,QAAQ,GAAG,CAAC,CAAA;AACtB,iBAAA;AACF,aAAA;AAAM,iBAAA,IAAI,WAAW,CAAC,UAAU,CAAC,iBAAiB,CAAC,EAAE;;AAEpD,gBAAA,MAAM,KAAK,GAAG,WAAW,CAAC,SAAS,CAAC,iBAAiB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;AACjE,gBAAA,IAAI,2BAA2B,CAAC,KAAK,CAAC,EAAE;AACtC,oBAAA,QAAQ,CAAC,OAAO,GAAG,KAAK,CAAA;AACzB,iBAAA;AACF,aAAA;AAAM,iBAAA,IAAI,WAAW,CAAC,UAAU,CAAC,iBAAiB,CAAC,EAAE;gBACpD,IAAI,WAAW,CAAC,MAAM,IAAI,iBAAiB,CAAC,MAAM,GAAG,CAAC;oBAAE,SAAQ;;AAEhE,gBAAA,MAAM,UAAU,GAAG,WAAW,CAAC,SAAS,CAAC,iBAAiB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;AACtE,gBAAA,IAAI,eAAe,CAAC,UAAU,CAAC,EAAE;AAC/B,oBAAA,QAAQ,CAAC,QAAQ,GAAG,UAAU,CAAA;AAC/B,iBAAA;AACF,aAAA;AAAM,iBAAA;;AAEL,gBAAA,QAAQ,GAAG,uCAAuC,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAA;AAC1E,aAAA;AACF,SAAA;AAED,QAAA,OAAO,QAAQ,CAAA;AAChB,KAAA;AAED,IAAA,OAAO,SAAS,CAAA;AAClB,CAAC;AAEM,MAAM,mCAAmC,GAAG,CACjD,EAAE,WAAW,EAAkB,EAC/B,mBAAiD,KACjB;;IAChC,IAAI,WAAW,KAAK,SAAS,EAAE;AAC7B,QAAA,MAAM,mBAAmB,GAAG,+BAA+B,CAAC,WAAW,CAAC,CAAA;QACxE,IAAI,mBAAmB,KAAK,SAAS;AAAE,YAAA,OAAO,mBAAmB,CAAA;;AAIjE,QAAA,MAAM,iBAAiB,GAAG,CAAA,EAAA,GAAAA,8BAAqB,CAAC,WAAW,EAAE,gCAAgC,CAAC,MAAA,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,EAAA,GAAIA,8BAAqB,CAAC,WAAW,EAAE,iCAAiC,CAAC,CAAA;AACvK,QAAA,MAAM,YAAY,GAAG,WAAW,CAAC,iBAAiB,CAAC,GAAG,iBAAiB,GAAG,mBAAmB,CAAC,YAAY,CAAA;AAE1G,QAAA,MAAM,aAAa,GAAG,CAAA,EAAA,GAAAA,8BAAqB,CAAC,WAAW,EAAE,2BAA2B,CAAC,MAAA,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,EAAA,GAAIA,8BAAqB,CAAC,WAAW,EAAE,4BAA4B,CAAC,CAAA;AACzJ,QAAA,MAAM,QAAQ,GAAG,sBAAsB,CAAC,aAAa,CAAC,GAAG,aAAa,GAAG,mBAAmB,CAAC,QAAQ,CAAA;AAErG,QAAA,MAAM,gBAAgB,GAAG,MAAM,CAC7B,CAAA,EAAA,GAAAA,8BAAqB,CAAC,WAAW,EAAE,+BAA+B,CAAC,MAAA,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,EAAA,GACnEA,8BAAqB,CAAC,WAAW,EAAE,gCAAgC,CAAC,CACrE,CAAA;AACD,QAAA,MAAM,WAAW,GAAmB,2BAA2B,CAAC,gBAAgB,CAAC,GAAG,gBAAkC,GAAG,mBAAmB,CAAC,WAAW,CAAA;AAExJ,QAAA,MAAM,oBAAoB,GAAG,MAAM,CACjC,CAAA,EAAA,GAAAA,8BAAqB,CAAC,WAAW,EAAE,mCAAmC,CAAC,MAAA,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,EAAA,GACvEA,8BAAqB,CAAC,WAAW,EAAE,oCAAoC,CAAC,CACzE,CAAA;AACD,QAAA,MAAM,eAAe,GAAmB,2BAA2B,CAAC,oBAAoB,CAAC,GAAG,oBAAsC,GAAG,mBAAmB,CAAC,eAAe,CAAA;AAExK,QAAA,MAAM,SAAS,GAAG,CAAA,EAAA,GAAAA,8BAAqB,CAAC,WAAW,EAAE,sBAAsB,CAAC,MAAA,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,EAAA,GAAIA,8BAAqB,CAAC,WAAW,EAAE,uBAAuB,CAAC,CAAA;AAC3I,QAAA,MAAM,IAAI,GAAG,WAAW,CAAC,SAAS,CAAC,GAAG,SAAS,GAAG,mBAAmB,CAAC,IAAI,CAAA;QAE1E,OAAY,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,EAAA,EAAA,mBAAmB,CAAE,EAAA,EAAA,YAAY,EAAE,QAAQ,EAAE,WAAW,EAAE,eAAe,EAAE,IAAI,EAAE,CAAA,CAAA;AAC9F,KAAA;AAAM,SAAA;AACL,QAAA,OAAO,mBAAmB,CAAA;AAC3B,KAAA;AACH,CAAC,CAAA;AAED,SAAS,iCAAiC,CAAE,QAAsC,EAAA;AAChF,IAAA,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,GAAG,QAAQ,GAAG,EAAE,CAAA;AAC9C,IAAA,MAAM,cAAc,GAAG,CAAA,YAAA,EAAe,QAAQ,CAAC,UAAU,IAAI,CAAA;AAC7D,IAAA,MAAM,OAAO,GAAG,CAAA,IAAA,EAAO,QAAQ,CAAC,QAAQ,IAAI,CAAA;IAC5C,MAAM,YAAY,GAAG,QAAQ,CAAC,QAAQ,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,GAAG,CAAA,SAAA,EAAY,QAAQ,CAAC,QAAQ,CAAA,EAAA,CAAI,GAAG,EAAE,CAAA;AAC/G,IAAA,MAAM,kBAAkB,GAAG,QAAQ,CAAC,YAAY,GAAG,IAAI,GAAG,EAAE,CAAA;AAC5D,IAAA,MAAM,SAAS,GAAG,CAAA,EAAG,kBAAkB,CAAA,EAAG,QAAQ,CAAC,WAAW,CAAI,CAAA,EAAA,QAAQ,CAAC,eAAe,CAAA,EAAG,QAAQ,CAAC,SAAS,EAAE,CAAA;AACjH,IAAA,MAAM,WAAW,GAAG,QAAQ,CAAC,OAAO,KAAK,EAAE,GAAG,CAAY,SAAA,EAAA,QAAQ,CAAC,OAAO,CAAA,EAAA,CAAI,GAAG,EAAE,CAAA;IACnF,OAAO,QAAQ,GAAG,cAAc,GAAG,OAAO,GAAG,YAAY,GAAG,WAAW,GAAG,SAAS,CAAA;AACrF,CAAC;AAED,SAAS,uBAAuB,CAAE,MAAc,EAAE,MAAc,EAAE,SAAiB,EAAA;;AAEjF,IAAA,KAAK,IAAI,CAAC,GAAG,SAAS,EAAE,CAAC,GAAG,MAAM,CAAC,QAAQ,EAAE,EAAE,CAAC,EAAE,EAAE;QAClD,MAAM,UAAU,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;AACpC,QAAA,IAAI,UAAU,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE;AACjC,YAAA,OAAO,CAAC,CAAA;AACT,SAAA;AACF,KAAA;AACD,IAAA,OAAO,SAAS,CAAA;AAClB,CAAC;AAEM,MAAM,yBAAyB,GAAG,CACvC,EAAE,WAAW,EAAkB,EAC/B,MAAc,EACd,QAAsC,KAC9B;IACR,IAAI,WAAW,KAAK,SAAS,EAAE;;QAG7B,MAAM,eAAe,GAAG,WAAW,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAA;AACvD,QAAA,MAAM,CAAC,GAAG,iCAAiC,CAAC,QAAQ,CAAC,CAAA;AACrD,QAAA,MAAM,oBAAoB,GAAG,CAAoB,iBAAA,EAAA,CAAC,IAAI,CAAA;AAEtD,QAAA,IAAI,WAAW,CAAC,iBAAiB,CAAC,KAAK,SAAS,EAAE;;YAEhD,MAAM,OAAO,GAAG,uBAAuB,CAAC,MAAM,EAAE,iBAAiB,EAAE,eAAe,CAAC,CAAA;YACnF,IAAI,OAAO,KAAK,SAAS;AAAE,gBAAA,MAAM,IAAI,KAAK,CAAC,qEAAqE,CAAC,CAAA;YACjH,MAAM,IAAI,GAAmB,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,EAAE,CAAA;AACrD,YAAA,MAAM,EAAE,GAAmB,EAAE,IAAI,EAAE,OAAO,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAA;YACvD,MAAM,CAAC,YAAY,CAAC,oBAAoB,EAAE,IAAI,EAAE,EAAE,CAAC,CAAA;AACpD,SAAA;AAAM,aAAA;;AAEL,YAAA,MAAM,IAAI,GAAmB,EAAE,IAAI,EAAE,eAAe,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAA;AACjE,YAAA,MAAM,EAAE,GAAmB,EAAE,IAAI,EAAE,eAAe,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAA;YAC/D,MAAM,CAAC,YAAY,CAAC,oBAAoB,EAAE,IAAI,EAAE,EAAE,CAAC,CAAA;AACpD,SAAA;AACF,KAAA;AAAM,SAAA;;AAEL,QAAA,MAAM,CAAC,GAAG,iCAAiC,CAAC,QAAQ,CAAC,CAAA;AACrD,QAAA,MAAM,cAAc,GAAG,CAAyB,sBAAA,EAAA,CAAC,WAAW,CAAA;QAC5D,MAAM,IAAI,GAAmB,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAA;QAC/C,MAAM,EAAE,GAAmB,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAA;QAC7C,MAAM,CAAC,YAAY,CAAC,cAAc,EAAE,IAAI,EAAE,EAAE,CAAC,CAAA;;AAE9C,KAAA;AACH,CAAC;;AClJD,MAAM,kBAAmB,SAAQC,cAAK,CAAA;IAGpC,WAAa,CAAA,GAAQ,EAAE,MAA2B,EAAA;QAChD,KAAK,CAAC,GAAG,CAAC,CAAA;AACV,QAAA,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;KACrB;IAED,MAAM,GAAA;AACJ,QAAA,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,GAAG,IAAI,CAAA;AACnC,QAAA,OAAO,CAAC,OAAO,CAAC,0CAA0C,CAAC,CAAA;AAE3D,QAAA,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,CAAA;AACxD,QAAA,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,mBAAmB,EAAE,CAAC,CAAA;AAEpE,QAAA,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,oEAAoE,EAAE,GAAG,EAAE,0BAA0B,EAAE,CAAC,CAAA;AAE1I,QAAA,MAAM,mBAAmB,GAAG,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,GAAG,EAAE,kCAAkC,EAAE,CAAC,CAAA;QAElG,MAAM,QAAQ,GAAG,mBAAmB,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAG,CAAC,CAAA;AAC5D,QAAA,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;AACtB,QAAA,QAAQ,CAAC,YAAY,CAAC,CAAC,EAAc,KAAI;YACvC,IAAI,CAAC,KAAK,EAAE,CAAA;AACZ,YAAA,OAAO,EAAE,CAAA;AACX,SAAC,CAAC,CAAA;QAEF,MAAM,SAAS,GAAG,mBAAmB,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAG,CAAC,CAAA;AAC7D,QAAA,SAAS,CAAC,OAAO,CAAC,gCAAgC,CAAC,CAAA;AACnD,QAAA,SAAS,CAAC,YAAY,CAAC,CAAC,EAAc,KAAI;AACxC,YAAA,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAA;YACvC,IAAI,CAAC,KAAK,EAAE,CAAA;AACZ,YAAA,OAAO,EAAE,CAAA;AACX,SAAC,CAAC,CAAA;QAEF,MAAM,gBAAgB,GAAG,mBAAmB,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAG,CAAC,CAAA;AACpE,QAAA,gBAAgB,CAAC,OAAO,CAAC,0DAA0D,CAAC,CAAA;AACpF,QAAA,gBAAgB,CAAC,YAAY,CAAC,CAAC,EAAc,KAAI;AAC/C,YAAA,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAA;YACtC,IAAI,CAAC,KAAK,EAAE,CAAA;AACZ,YAAA,OAAO,EAAE,CAAA;AACX,SAAC,CAAC,CAAA;KACH;IAED,OAAO,GAAA;AACL,QAAA,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,GAAG,IAAI,CAAA;QACnC,SAAS,CAAC,KAAK,EAAE,CAAA;QACjB,OAAO,CAAC,KAAK,EAAE,CAAA;KAChB;AACF,CAAA;SAEe,wBAAwB,CAAE,GAAQ,EAAE,QAAsC,EAAE,QAAkB,EAAA;AAC5G,IAAA,MAAM,oBAAoB,GAAG,CAAC,iBAA0B,KAAU;AAChE,QAAA,MAAM,eAAe,GAAA,MAAA,CAAA,MAAA,CAAA,EAAA,EAAQ,QAAQ,CAAE,CAAA;AACvC,QAAA,IAAI,iBAAiB;AAAE,YAAA,eAAe,CAAC,IAAI,GAAG,IAAI,CAAA;QAClD,yBAAyB,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;AAC5E,KAAC,CAAA;AACD,IAAA,MAAM,MAAM,GAAwB;AAClC,QAAA,OAAO,EAAE,CAAA;;AAEe,2BAAA,CAAA;AACxB,QAAA,mBAAmB,EAAE,CAAA,wBAAA,EAA2B,QAAQ,CAAC,YAAY,CAAA;AAClD,qBAAA,EAAA,QAAQ,CAAC,UAAU,CAAA;AACN,kCAAA,EAAA,QAAQ,CAAC,OAAO,CAAA;AAC3B,uBAAA,EAAA,QAAQ,CAAC,QAAQ,CAAA;AACZ,4BAAA,EAAA,QAAQ,CAAC,WAAW,CAAA;AACA,gDAAA,EAAA,QAAQ,CAAC,eAAe,CAAA;AAC7D,WAAA,EAAA,QAAQ,CAAC,SAAS,CAAA;4BACH,QAAQ,CAAC,QAAQ,CAAE,CAAA;QAC3C,oBAAoB;KACrB,CAAA;AAED,IAAA,MAAM,IAAI,GAAG,GAAG,CAAC,SAAS,CAAC,UAAU,CAAA;AACrC,IAAA,IAAI,IAAI,EAAE;QACR,IAAI,kBAAkB,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,IAAI,EAAE,CAAA;AAC3C,KAAA;AACH;;AChFA,MAAM,oBAAoB,GAAG,GAAG,CAAA;AAEhC,SAAS,qBAAqB,CAAE,MAAc,EAAE,OAAqB,EAAA;IACnE,MAAM,KAAK,GAAG,aAAa,CAAA;AAC3B,IAAA,MAAM,iBAAiB,GAAG,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;AACrE,IAAA,IAAI,CAAC,iBAAiB;AAAE,QAAA,OAAO,SAAS,CAAA;IAExC,MAAM,OAAO,GAAG,iBAAiB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;AAC9C,IAAA,IAAI,CAAC,OAAO;AAAE,QAAA,OAAO,SAAS,CAAA;AAE9B,IAAA,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;;QAExB,OAAO,CAAC,GAAG,CAAC,8BAA8B,GAAG,iBAAiB,GAAG,GAAG,CAAC,CAAA;AACrE,QAAA,OAAO,SAAS,CAAA;AACjB,KAAA;AAED,IAAA,MAAM,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;AACxB,IAAA,OAAO,KAAK,CAAC,QAAQ,EAAE,CAAA;AACzB,CAAC;AAED,SAAS,sBAAsB,CAAE,MAAc,EAAE,OAAqB,EAAE,KAAmB,EAAA;IACzF,MAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAA;IAC9C,MAAM,QAAQ,GAAG,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,CAAA;IAC3C,OAAO,uBAAuB,CAAC,QAAQ,EAAE,UAAU,EAAE,KAAK,CAAC,CAAA;AAC7D,CAAC;AAED,SAAS,sBAAsB,CAAE,KAAa,EAAA;AAC5C,IAAA,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;QACvB,MAAM,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;AAC1B,QAAA,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE;AAChB,YAAA,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAA;AACnB,SAAA;AACF,KAAA;AACD,IAAA,OAAO,KAAK,CAAC,IAAI,EAAE,CAAA;AACrB,CAAC;AAED;AACA,SAAS,cAAc,CAAE,CAAe,EAAE,QAAsC,EAAE,mBAA2B,EAAA;AAC3G,IAAA,MAAM,IAAI,GAAG,CAAC,CAAC,OAAO,CAAA;AACtB,IAAA,MAAM,SAAS,GAAG,sBAAsB,CAAC,IAAI,CAAC,CAAA;IAE9C,IAAI,YAAY,GAAG,EAAE,CAAA;IACrB,MAAM,UAAU,GAAG,mBAAmB,CAAA;AACtC,IAAA,KAAK,IAAI,CAAC,GAAG,UAAU,EAAE,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;QACzC,YAAY,IAAI,IAAI,CAAA;AACrB,KAAA;AAED,IAAA,MAAM,SAAS,GAAG,CAAA,GAAA,EAAM,IAAI,CAAI,CAAA,EAAA,SAAS,IAAI,CAAA;AAE7C,IAAA,OAAO,YAAY,GAAG,oBAAoB,GAAG,GAAG,GAAG,SAAS,CAAA;AAC9D,CAAC;AAED;AACA,SAAS,wBAAwB,CAAE,MAAc,EAAE,OAAuB,EAAE,KAAkB,EAAE,IAAY,EAAA;AAC1G,IAAA,MAAM,YAAY,GAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC,CAAA;IAE1D,IAAI,YAAY,KAAK,IAAI,EAAE;QACzB,OAAO,CAAC,IAAI,CAAC;AACX,YAAA,IAAI,EAAE,IAAI;YACV,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,EAAE,EAAE,KAAK,CAAC,EAAE;AACb,SAAA,CAAC,CAAA;AACH,KAAA;AACH,CAAC;AAEM,MAAM,sBAAsB,GAAG,CACpC,QAA8B,EAC9B,QAAsC,KAC9B;;AACR,IAAA,IAAI,CAAC,QAAQ;QAAE,OAAM;IACrB,MAAM,QAAQ,GAAG,CAAA,EAAA,GAAA,QAAQ,CAAC,IAAI,CAAC,QAAQ,MAAI,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,EAAA,GAAA,EAAE,CAAA;AAC7C,IAAA,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAA;AAC9B,IAAA,MAAM,YAAY,GAAG,8BAA8B,CAAC,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAA;IAEnG,IAAI,aAAa,GAAG,CAAC,CAAA;AAErB,IAAA,IAAI,cAAc,GAAqB,CAAC,sBAAsB,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAA;AAEvG,IAAA,IAAI,QAAQ,CAAC,UAAU,GAAG,CAAC,EAAE;AAC3B,QAAA,aAAa,GAAG,QAAQ,CAAC,UAAU,CAAA;AACpC,KAAA;SAAM,IAAI,QAAQ,CAAC,YAAY,EAAE;QAChC,aAAa,GAAG,CAAC,CAAA;AAClB,KAAA;IAED,MAAM,OAAO,GAAmB,EAAE,CAAA;AAElC,IAAA,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE;;AAG9B,QAAA,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAA;;AAG3B,QAAA,IAAI,CAAC,QAAQ,CAAC,UAAU,GAAG,KAAK,MAAM,QAAQ,CAAC,YAAY,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE;;;;AAK3E,YAAA,cAAc,GAAG,CAAC,sBAAsB,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAA;AAEjF,YAAA,IAAI,QAAQ,CAAC,UAAU,GAAG,CAAC,EAAE;AAC3B,gBAAA,aAAa,GAAG,QAAQ,CAAC,UAAU,CAAA;AACpC,aAAA;iBAAM,IAAI,QAAQ,CAAC,YAAY,EAAE;gBAChC,aAAa,GAAG,CAAC,CAAA;AAClB,aAAA;YACD,SAAQ;AACT,SAAA;;QAGD,IAAI,KAAK,KAAK,aAAa,EAAE;AAC3B,YAAA,MAAM,CAAC,GAAG,cAAc,CAAC,GAAG,EAAE,CAAA;YAC9B,IAAI,CAAC,KAAK,SAAS,EAAE;gBACnB,cAAc,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAA;AAC3C,aAAA;AACF,SAAA;aAAM,IAAI,KAAK,GAAG,aAAa,EAAE;YAChC,KAAK,IAAI,CAAC,GAAG,aAAa,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE;gBAC1C,cAAc,CAAC,GAAG,EAAE,CAAA;AACrB,aAAA;AACD,YAAA,MAAM,CAAC,GAAG,cAAc,CAAC,GAAG,EAAE,CAAA;YAC9B,IAAI,CAAC,KAAK,SAAS,EAAE;gBACnB,cAAc,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAA;AAC3C,aAAA;AACF,SAAA;aAAM,IAAI,KAAK,GAAG,aAAa,EAAE;YAChC,KAAK,IAAI,CAAC,GAAG,aAAa,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE;gBAC1C,cAAc,CAAC,IAAI,CAAC,0BAA0B,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAA;AAC1E,aAAA;AACF,SAAA;;QAGD,aAAa,GAAG,KAAK,CAAA;AAErB,QAAA,IAAI,KAAK,GAAG,QAAQ,CAAC,QAAQ,EAAE;;YAE7B,SAAQ;AACT,SAAA;;QAGD,MAAM,WAAW,GAAG,sBAAsB,CAAC,MAAM,EAAE,OAAO,EAAE,YAAY,CAAC,CAAA;QACzE,IAAI,WAAW,KAAK,SAAS;YAAE,OAAM;QACrC,MAAM,iBAAiB,GAAG,qBAAqB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAChE,IAAI,iBAAiB,KAAK,SAAS;YAAE,OAAM;AAC3C,QAAA,MAAM,YAAY,GAAG,mBAAmB,CAAC,cAAc,CAAC,CAAA;AACxD,QAAA,wBAAwB,CAAC,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,iBAAiB,GAAG,YAAY,GAAG,QAAQ,CAAC,SAAS,GAAG,GAAG,CAAC,CAAA;AACpH,KAAA;;AAGD,IAAA,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;;QAEtB,OAAO,CAAC,GAAG,CAAC,8DAA8D,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;QAC3F,MAAM,CAAC,WAAW,CAAC;AACjB,YAAA,OAAO,EAAE,OAAO;AACjB,SAAA,CAAC,CAAA;AACH,KAAA;AACH,CAAC,CAAA;AAEM,MAAM,qBAAqB,GAAG,CACnC,QAA8B,EAC9B,QAAsC,KAC9B;;AACR,IAAA,IAAI,CAAC,QAAQ;QAAE,OAAM;IACrB,MAAM,QAAQ,GAAG,CAAA,EAAA,GAAA,QAAQ,CAAC,IAAI,CAAC,QAAQ,MAAI,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,EAAA,GAAA,EAAE,CAAA;AAC7C,IAAA,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAA;AAE9B,IAAA,IAAI,CAAC,qBAAqB,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAAE,OAAM;AAErD,IAAA,IAAI,UAAoC,CAAA;IACxC,IAAI,UAAU,GAAG,IAAI,CAAA;IACrB,MAAM,OAAO,GAAmB,EAAE,CAAA;;IAGlC,IAAI,mBAAmB,GAAG,CAAC,CAAA;AAC3B,IAAA,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE;AACvB,QAAA,mBAAmB,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,CAAA;AACxC,KAAA;AAED,IAAA,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE;;;QAI9B,IAAI,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE;YAC/C,UAAU,GAAG,OAAO,CAAA;AACrB,SAAA;AAED;;;;AAIE;QAEF,MAAM,QAAQ,GAAG,cAAc,CAAC,OAAO,EAAE,QAAQ,EAAE,mBAAmB,CAAC,CAAA;AACvE,QAAA,UAAU,IAAI,QAAQ,GAAG,IAAI,CAAA;AAC9B,KAAA;;AAGD,IAAA,IAAI,UAAU,EAAE;AACd,QAAA,MAAM,IAAI,GAAG;YACX,IAAI,EAAE,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC;AACxC,YAAA,EAAE,EAAE,CAAC;SACN,CAAA;;QAGD,MAAM,YAAY,GAAG,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,CAAA;QACvD,IAAI,UAAU,GAAG,YAAY,CAAA;QAC7B,IAAI,SAAS,GAAG,KAAK,CAAA;AACrB,QAAA,MAAM,gBAAgB,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAA;QAC1C,QAAS,UAAU,EAAE,EAAE;YACrB,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,CAAA;AACvC,YAAA,IAAI,IAAI,KAAK,SAAS,IAAI,UAAU,GAAG,gBAAgB,EAAE;;gBAEvD,UAAU,GAAG,YAAY,CAAA;gBACzB,MAAK;AACN,aAAA;AACD,YAAA,MAAM,eAAe,GAAG,IAAI,CAAC,SAAS,EAAE,CAAA;AACxC,YAAA,IAAI,SAAS,EAAE;AACb,gBAAA,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,oBAAoB,CAAC;oBAAE,MAAK;AAC5D,gBAAA,IAAI,eAAe,CAAC,UAAU,CAAC,GAAG,CAAC;oBAAE,MAAK;AAC3C,aAAA;AAAM,iBAAA;AACL,gBAAA,IAAI,eAAe,CAAC,UAAU,CAAC,oBAAoB,CAAC,EAAE;oBACpD,SAAS,GAAG,IAAI,CAAA;AACjB,iBAAA;AAAM,qBAAA,IAAI,eAAe,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;;oBAE1C,UAAU,GAAG,YAAY,CAAA;oBACzB,MAAK;AACN,iBAAA;AAAM,qBAAA;oBACL,SAAQ;AACT,iBAAA;AACF,aAAA;AACF,SAAA;QAED,IAAI,UAAU,KAAK,IAAI,EAAE;YACvB,UAAU,GAAG,EAAE,CAAA;AAChB,SAAA;AAED,QAAA,MAAM,EAAE,GAAG;AACT,YAAA,IAAI,EAAE,UAAU;AAChB,YAAA,EAAE,EAAE,CAAC;SACN,CAAA;AACD,QAAA,MAAM,KAAK,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,CAAA;QAC1B,wBAAwB,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,CAAC,CAAA;AAC7D,KAAA;;AAGD,IAAA,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;;QAEtB,OAAO,CAAC,GAAG,CAAC,6DAA6D,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;QAC1F,MAAM,CAAC,WAAW,CAAC;AACjB,YAAA,OAAO,EAAE,OAAO;AACjB,SAAA,CAAC,CAAA;AACH,KAAA;AACH,CAAC,CAAA;AAEM,MAAM,sBAAsB,GAAG,CACpC,QAA8B,KACtB;;AACR,IAAA,IAAI,CAAC,QAAQ;QAAE,OAAM;IACrB,MAAM,QAAQ,GAAG,CAAA,EAAA,GAAA,QAAQ,CAAC,IAAI,CAAC,QAAQ,MAAI,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,EAAA,GAAA,EAAE,CAAA;AAC7C,IAAA,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAA;IAE9B,MAAM,OAAO,GAAmB,EAAE,CAAA;AAElC,IAAA,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE;AAC9B,QAAA,MAAM,WAAW,GAAG,sBAAsB,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAA;QAC5F,IAAI,WAAW,KAAK,SAAS;YAAE,OAAM;QACrC,MAAM,iBAAiB,GAAG,qBAAqB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAChE,IAAI,iBAAiB,KAAK,SAAS;YAAE,OAAM;QAC3C,wBAAwB,CAAC,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,iBAAiB,GAAG,GAAG,CAAC,CAAA;AAChF,KAAA;AAED,IAAA,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;QACtB,MAAM,CAAC,WAAW,CAAC;AACjB,YAAA,OAAO,EAAE,OAAO;AACjB,SAAA,CAAC,CAAA;AACH,KAAA;AACH,CAAC;;AC9QD,MAAM,8BAA+B,SAAQC,yBAAgB,CAAA;IAG3D,WAAa,CAAA,GAAQ,EAAE,MAA4B,EAAA;AACjD,QAAA,KAAK,CAAC,GAAG,EAAE,MAAM,CAAC,CAAA;AAClB,QAAA,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;KACrB;IAED,OAAO,GAAA;AACL,QAAA,MAAM,EAAE,WAAW,EAAE,GAAG,IAAI,CAAA;QAE5B,WAAW,CAAC,KAAK,EAAE,CAAA;QAEnB,WAAW,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,4BAA4B,EAAE,CAAC,CAAA;QAElE,WAAW,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,2JAA2J,EAAE,CAAC,CAAA;AAElM,QAAA,WAAW,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,CAAA;QAE9B,WAAW,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,4KAA4K,EAAE,CAAC,CAAA;AAEnN,QAAA,WAAW,CAAC,QAAQ,CAAC,KAAK,EAAE;AAC1B,YAAA,IAAI,EAAE,CAAA;;;;;;AAMJ,OAAA,CAAA;AACH,SAAA,CAAC,CAAA;AAEF,QAAA,WAAW,CAAC,QAAQ,CAAC,KAAK,EAAE;AAC1B,YAAA,IAAI,EAAE,CAAA;;;AAGP,IAAA,CAAA;AACA,SAAA,CAAC,CAAA;QAEF,MAAM,EAAE,GAAG,WAAW,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,CAAA;QAEzC,MAAM,GAAG,GAAG,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAG,CAAC,CAAA;QAClC,GAAG,CAAC,QAAQ,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,qBAAqB,EAAE,CAAC,CAAA;QAClD,GAAG,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,qEAAqE,EAAE,CAAC,CAAA;QAErG,MAAM,GAAG,GAAG,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAG,CAAC,CAAA;QAClC,GAAG,CAAC,QAAQ,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,uBAAuB,EAAE,CAAC,CAAA;QACpD,GAAG,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,8EAA8E,EAAE,CAAC,CAAA;QAE9G,MAAM,GAAG,GAAG,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAG,CAAC,CAAA;QAClC,GAAG,CAAC,QAAQ,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,kCAAkC,EAAE,CAAC,CAAA;QAC/D,GAAG,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,6FAA6F,EAAE,CAAC,CAAA;QAE7H,MAAM,GAAG,GAAG,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAG,CAAC,CAAA;QAClC,GAAG,CAAC,QAAQ,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,yBAAyB,EAAE,CAAC,CAAA;QACtD,GAAG,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,qEAAqE,EAAE,CAAC,CAAA;QAErG,MAAM,GAAG,GAAG,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAG,CAAC,CAAA;QAClC,GAAG,CAAC,QAAQ,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,0BAA0B,EAAE,CAAC,CAAA;QACvD,GAAG,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,+HAA+H,EAAE,CAAC,CAAA;QAE/J,MAAM,GAAG,GAAG,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAG,CAAC,CAAA;QAClC,GAAG,CAAC,QAAQ,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC,CAAA;AAC9C,QAAA,GAAG,CAAC,QAAQ,CAAC,MAAM,EAAE;AACnB,YAAA,IAAI,EAAE,CAAA;;;AAGY,uBAAA,CAAA;AACnB,SAAA,CAAC,CAAA;QAEF,MAAM,GAAG,GAAG,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,CAAA;AAClC,QAAA,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE;AACjB,YAAA,IAAI,EAAE,CAAA;;AAEP,IAAA,CAAA;AACA,SAAA,CAAC,CAAA;AACF,QAAA,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE;AACjB,YAAA,IAAI,EAAE,CAAA;;AAEP,IAAA,CAAA;AACA,SAAA,CAAC,CAAA;AACF,QAAA,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE;AACjB,YAAA,IAAI,EAAE,CAAA;;AAEP,IAAA,CAAA;AACA,SAAA,CAAC,CAAA;AACF,QAAA,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE;AACjB,YAAA,IAAI,EAAE,CAAA;;AAEP,IAAA,CAAA;AACA,SAAA,CAAC,CAAA;AACF,QAAA,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE;AACjB,YAAA,IAAI,EAAE,CAAA;;AAEP,IAAA,CAAA;AACA,SAAA,CAAC,CAAA;AACF,QAAA,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE;AACjB,YAAA,IAAI,EAAE,CAAA;;AAEP,IAAA,CAAA;AACA,SAAA,CAAC,CAAA;QAEF,IAAIC,gBAAO,CAAC,WAAW,CAAC;aACrB,OAAO,CAAC,wBAAwB,CAAC;aACjC,OAAO,CAAC,sEAAsE,CAAC;AAC/E,aAAA,SAAS,CAAC,MAAM,IAAI,MAAM;aACxB,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAC;aAC3C,UAAU,CAAC,wBAAwB,CAAC;AACpC,aAAA,QAAQ,CAAC,CAAO,KAAK,KAAI,SAAA,CAAA,IAAA,EAAA,KAAA,CAAA,EAAA,KAAA,CAAA,EAAA,aAAA;YACxB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,GAAG,KAAK,CAAA;AACzC,YAAA,MAAM,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAA;SACjC,CAAA,CAAC,CAAC,CAAA;QAEP,IAAIA,gBAAO,CAAC,WAAW,CAAC;aACrB,OAAO,CAAC,qBAAqB,CAAC;aAC9B,OAAO,CAAC,gCAAgC,CAAC;AACzC,aAAA,SAAS,CAAC,MAAM,IAAI,MAAM;AACxB,aAAA,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;aAClB,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC;AACzC,aAAA,iBAAiB,EAAE;AACnB,aAAA,QAAQ,CAAC,CAAO,KAAK,KAAI,SAAA,CAAA,IAAA,EAAA,KAAA,CAAA,EAAA,KAAA,CAAA,EAAA,aAAA;YACxB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,GAAG,KAAK,CAAA;AACvC,YAAA,MAAM,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAA;SACjC,CAAA,CAAC,CAAC,CAAA;QAEP,IAAIA,gBAAO,CAAC,WAAW,CAAC;aACrB,OAAO,CAAC,oBAAoB,CAAC;aAC7B,OAAO,CAAC,0DAA0D,CAAC;AACnE,aAAA,OAAO,CAAC,IAAI,IAAI,IAAI;aAClB,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC;AACtC,aAAA,QAAQ,CAAC,CAAO,KAAK,KAAI,SAAA,CAAA,IAAA,EAAA,KAAA,CAAA,EAAA,KAAA,CAAA,EAAA,aAAA;YACxB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,GAAG,KAAK,CAAA;AACpC,YAAA,MAAM,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAA;SACjC,CAAA,CAAC,CAAC,CAAA;QAEP,IAAIA,gBAAO,CAAC,WAAW,CAAC;aACrB,OAAO,CAAC,uBAAuB,CAAC;aAChC,OAAO,CAAC,kCAAkC,CAAC;AAC3C,aAAA,SAAS,CAAC,MAAM,IAAI,MAAM;AACxB,aAAA,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;aAClB,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC;AACvC,aAAA,iBAAiB,EAAE;AACnB,aAAA,QAAQ,CAAC,CAAO,KAAK,KAAI,SAAA,CAAA,IAAA,EAAA,KAAA,CAAA,EAAA,KAAA,CAAA,EAAA,aAAA;YACxB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,GAAG,KAAK,CAAA;AACrC,YAAA,MAAM,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAA;SACjC,CAAA,CAAC,CAAC,CAAA;QAEP,IAAIA,gBAAO,CAAC,WAAW,CAAC;aACrB,OAAO,CAAC,4BAA4B,CAAC;aACrC,OAAO,CAAC,4IAA4I,CAAC;AACrJ,aAAA,OAAO,CAAC,IAAI,IAAI,IAAI;aAClB,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC;AAC1C,aAAA,QAAQ,CAAC,CAAO,KAAK,KAAI,SAAA,CAAA,IAAA,EAAA,KAAA,CAAA,EAAA,KAAA,CAAA,EAAA,aAAA;YACxB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,GAAG,KAAuB,CAAA;AAC1D,YAAA,MAAM,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAA;SACjC,CAAA,CAAC,CAAC,CAAA;QAEP,IAAIA,gBAAO,CAAC,WAAW,CAAC;aACrB,OAAO,CAAC,gDAAgD,CAAC;aACzD,OAAO,CAAC,kJAAkJ,CAAC;AAC3J,aAAA,OAAO,CAAC,IAAI,IAAI,IAAI;aAClB,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAC;AAC9C,aAAA,QAAQ,CAAC,CAAO,KAAK,KAAI,SAAA,CAAA,IAAA,EAAA,KAAA,CAAA,EAAA,KAAA,CAAA,EAAA,aAAA;YACxB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,GAAG,KAAuB,CAAA;AAC9D,YAAA,MAAM,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAA;SACjC,CAAA,CAAC,CAAC,CAAA;QAEP,IAAIA,gBAAO,CAAC,WAAW,CAAC;aACrB,OAAO,CAAC,qBAAqB,CAAC;aAC9B,OAAO,CAAC,4CAA4C,CAAC;AACrD,aAAA,SAAS,CAAC,MAAM,IAAI,MAAM;aACxB,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC;aACnC,UAAU,CAAC,6BAA6B,CAAC;AACzC,aAAA,QAAQ,CAAC,CAAO,KAAK,KAAI,SAAA,CAAA,IAAA,EAAA,KAAA,CAAA,EAAA,KAAA,CAAA,EAAA,aAAA;YACxB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,GAAG,KAAK,CAAA;AACjC,YAAA,MAAM,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAA;SACjC,CAAA,CAAC,CAAC,CAAA;QAEP,IAAIA,gBAAO,CAAC,WAAW,CAAC;aACrB,OAAO,CAAC,iBAAiB,CAAC;aAC1B,OAAO,CAAC,8PAA8P,CAAC;AACvQ,aAAA,OAAO,CAAC,IAAI,IAAI,IAAI;aAClB,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC;AACxC,aAAA,QAAQ,CAAC,CAAO,KAAK,KAAI,SAAA,CAAA,IAAA,EAAA,KAAA,CAAA,EAAA,KAAA,CAAA,EAAA,aAAA;YACxB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,GAAG,KAAK,CAAA;AACtC,YAAA,MAAM,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAA;SACjC,CAAA,CAAC,CAAC,CAAA;QAEP,IAAIA,gBAAO,CAAC,WAAW,CAAC;aACrB,OAAO,CAAC,0BAA0B,CAAC;aACnC,OAAO,CAAC,oJAAoJ,CAAC;AAC7J,aAAA,OAAO,CAAC,IAAI,IAAI,IAAI;aAClB,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC;AACvC,aAAA,QAAQ,CAAC,CAAO,KAAK,KAAI,SAAA,CAAA,IAAA,EAAA,KAAA,CAAA,EAAA,KAAA,CAAA,EAAA,aAAA;YACxB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,GAAG,KAAK,CAAA;AACrC,YAAA,MAAM,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAA;SACjC,CAAA,CAAC,CAAC,CAAA;KACR;AACF,CAAA;AAEoB,MAAA,oBAAqB,SAAQC,eAAM,CAAA;IAGhD,MAAM,GAAA;;;YAEV,OAAO,CAAC,IAAI,CAAC,0CAA0C,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAA;AAEhF,YAAA,MAAM,IAAI,CAAC,YAAY,EAAE,CAAA;YAEzB,IAAI,CAAC,UAAU,CAAC;AACd,gBAAA,EAAE,EAAE,8BAA8B;AAClC,gBAAA,IAAI,EAAE,oDAAoD;AAC1D,gBAAA,aAAa,EAAE,CAAC,QAAiB,KAAI;AACnC,oBAAA,IAAI,QAAQ;AAAE,wBAAA,OAAO,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;oBAE3C,MAAM,QAAQ,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACtC,oBAAA,IAAI,QAAQ,EAAE;AACZ,wBAAA,MAAM,QAAQ,GAAG,mCAAmC,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;AAClF,wBAAA,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;wBAC1C,UAAU,CAAC,MAAK;;4BAEd,MAAM,qBAAqB,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACnD,4BAAA,qBAAqB,CAAC,qBAAqB,EAAE,QAAQ,CAAC,CAAA;yBACvD,EAAE,IAAI,CAAC,CAAA;wBAER,wBAAwB,CAAC,IAAI,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAA;AACvD,qBAAA;AAED,oBAAA,OAAO,KAAK,CAAA;iBACb;AACF,aAAA,CAAC,CAAA;YAEF,IAAI,CAAC,UAAU,CAAC;AACd,gBAAA,EAAE,EAAE,iBAAiB;AACrB,gBAAA,IAAI,EAAE,iCAAiC;AACvC,gBAAA,aAAa,EAAE,CAAC,QAAiB,KAAI;AACnC,oBAAA,IAAI,QAAQ;AAAE,wBAAA,OAAO,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;oBAE3C,MAAM,QAAQ,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACtC,oBAAA,IAAI,QAAQ,EAAE;AACZ,wBAAA,MAAM,QAAQ,GAAG,mCAAmC,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;AAClF,wBAAA,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;wBAC1C,UAAU,CAAC,MAAK;;4BAEd,MAAM,qBAAqB,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACnD,4BAAA,qBAAqB,CAAC,qBAAqB,EAAE,QAAQ,CAAC,CAAA;yBACvD,EAAE,IAAI,CAAC,CAAA;;;;AAKT,qBAAA;AAED,oBAAA,OAAO,KAAK,CAAA;iBACb;AACF,aAAA,CAAC,CAAA;YAEF,IAAI,CAAC,UAAU,CAAC;AACd,gBAAA,EAAE,EAAE,wBAAwB;AAC5B,gBAAA,IAAI,EAAE,gDAAgD;AACtD,gBAAA,aAAa,EAAE,CAAC,QAAiB,KAAI;AACnC,oBAAA,IAAI,QAAQ;AAAE,wBAAA,OAAO,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;oBAE3C,MAAM,QAAQ,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;oBACtC,sBAAsB,CAAC,QAAQ,CAAC,CAAA;AAEhC,oBAAA,OAAO,IAAI,CAAA;iBACZ;AACF,aAAA,CAAC,CAAA;YAEF,IAAI,CAAC,UAAU,CAAC;AACd,gBAAA,EAAE,EAAE,+BAA+B;AACnC,gBAAA,IAAI,EAAE,+BAA+B;AACrC,gBAAA,aAAa,EAAE,CAAC,QAAiB,KAAI;AACnC,oBAAA,IAAI,QAAQ;AAAE,wBAAA,OAAO,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;oBAE3C,MAAM,QAAQ,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACtC,oBAAA,IAAI,QAAQ,EAAE;AACZ,wBAAA,MAAM,QAAQ,GAAG,mCAAmC,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;wBAClF,yBAAyB,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;AACpE,qBAAA;AAED,oBAAA,OAAO,KAAK,CAAA;iBACb;AACF,aAAA,CAAC,CAAA;AAEF,YAAA,IAAI,CAAC,aAAa,CAAC,IAAI,8BAA8B,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAA;YAEtE,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,WAAW,CAAC,MAAK;gBAC5C,MAAM,QAAQ,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACtC,gBAAA,IAAI,QAAQ,EAAE;AACZ,oBAAA,MAAM,QAAQ,GAAG,mCAAmC,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;oBAElF,IAAI,QAAQ,CAAC,IAAI,EAAE;AACjB,wBAAA,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;wBAC1C,UAAU,CAAC,MAAK;;4BAEd,MAAM,qBAAqB,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACnD,4BAAA,qBAAqB,CAAC,qBAAqB,EAAE,QAAQ,CAAC,CAAA;yBACvD,EAAE,IAAI,CAAC,CAAA;;AAER,wBAAA,OAAO,CAAC,GAAG,CAAC,yDAAyD,CAAC,CAAA;AACvE,qBAAA;AACF,iBAAA;AACH,aAAC,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC,CAAA;SACf,CAAA,CAAA;AAAA,KAAA;IAEK,YAAY,GAAA;;AAChB,YAAA,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,EAAE,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAA;SAC3E,CAAA,CAAA;AAAA,KAAA;IAEK,YAAY,GAAA;;YAChB,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;SACnC,CAAA,CAAA;AAAA,KAAA;AACF;;;;"} diff --git a/.obsidian/plugins/number-headings-obsidian/manifest.json b/.obsidian/plugins/number-headings-obsidian/manifest.json new file mode 100644 index 0000000..6d222bf --- /dev/null +++ b/.obsidian/plugins/number-headings-obsidian/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "number-headings-obsidian", + "name": "Number Headings", + "version": "1.13.0", + "minAppVersion": "0.12.0", + "description": "Automatically number or re-number headings in an Obsidian document", + "author": "Kevin Albrecht (onlyafly@gmail.com)", + "authorUrl": "https://www.kevinalbrecht.com", + "isDesktopOnly": false +} \ No newline at end of file diff --git a/.obsidian/plugins/number-headings-obsidian/styles.css b/.obsidian/plugins/number-headings-obsidian/styles.css new file mode 100644 index 0000000..12a666b --- /dev/null +++ b/.obsidian/plugins/number-headings-obsidian/styles.css @@ -0,0 +1,8 @@ +div.number-headings-button-container > button { + font-weight: normal; +} + +div.number-headings-question { + font-weight: bold; + margin-bottom: 10px; +} \ No newline at end of file diff --git a/.obsidian/plugins/obsidian-custom-attachment-location/main.js b/.obsidian/plugins/obsidian-custom-attachment-location/main.js new file mode 100644 index 0000000..115b968 --- /dev/null +++ b/.obsidian/plugins/obsidian-custom-attachment-location/main.js @@ -0,0 +1,318 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ESBUILD +if you want to view the source, please visit the github repository of this plugin +*/ + +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod)); +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); +var __async = (__this, __arguments, generator) => { + return new Promise((resolve, reject) => { + var fulfilled = (value) => { + try { + step(generator.next(value)); + } catch (e) { + reject(e); + } + }; + var rejected = (value) => { + try { + step(generator.throw(value)); + } catch (e) { + reject(e); + } + }; + var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected); + step((generator = generator.apply(__this, __arguments)).next()); + }); +}; + +// main.ts +var main_exports = {}; +__export(main_exports, { + default: () => CustomAttachmentLocation +}); +module.exports = __toCommonJS(main_exports); +var import_obsidian = require("obsidian"); +var Path = __toESM(require("path")); +var DEFAULT_SETTINGS = { + attachmentFolderPath: "./assets/${filename}", + pastedImageFileName: "image-${date}", + dateTimeFormat: "YYYYMMDDHHmmssSSS", + autoRenameFolder: true, + autoRenameFiles: false +}; +var originalSettings = { + attachmentFolderPath: "" +}; +var blobToArrayBuffer = (blob) => { + return new Promise((resolve) => { + const reader = new FileReader(); + reader.onloadend = () => resolve(reader.result); + reader.readAsArrayBuffer(blob); + }); +}; +var TemplateString = class extends String { + interpolate(params) { + const names = Object.keys(params); + const vals = Object.values(params); + return new Function(...names, `return \`${this}\`;`)(...vals); + } +}; +var CustomAttachmentLocation = class extends import_obsidian.Plugin { + constructor() { + super(...arguments); + this.useRelativePath = false; + } + onload() { + return __async(this, null, function* () { + console.log("loading plugin"); + this.adapter = this.app.vault.adapter; + yield this.loadSettings(); + this.backupConfigs(); + this.addSettingTab(new CustomAttachmentLocationSettingTab(this.app, this)); + this.registerEvent(this.app.workspace.on("editor-paste", this.handlePaste.bind(this))); + this.registerEvent(this.app.workspace.on("editor-drop", this.handleDrop.bind(this))); + this.registerEvent(this.app.workspace.on("file-open", this.handleFileOpen.bind(this))); + this.registerEvent(this.app.vault.on("rename", this.handleRename.bind(this))); + }); + } + onunload() { + console.log("unloading plugin"); + this.restoreConfigs(); + } + loadSettings() { + return __async(this, null, function* () { + this.settings = Object.assign({}, DEFAULT_SETTINGS, yield this.loadData()); + if (this.settings.attachmentFolderPath.startsWith("./")) + this.useRelativePath = true; + else + this.useRelativePath = false; + }); + } + saveSettings() { + return __async(this, null, function* () { + yield this.saveData(this.settings); + }); + } + backupConfigs() { + originalSettings.attachmentFolderPath = this.app.vault.getConfig("attachmentFolderPath"); + } + restoreConfigs() { + this.app.vault.setConfig("attachmentFolderPath", originalSettings.attachmentFolderPath); + } + updateAttachmentFolderConfig(path) { + this.app.vault.setConfig("attachmentFolderPath", path); + } + getAttachmentFolderPath(mdFileName) { + let path = new TemplateString(this.settings.attachmentFolderPath).interpolate({ + filename: mdFileName + }); + return path; + } + getAttachmentFolderFullPath(mdFolderPath, mdFileName) { + let attachmentFolder = ""; + if (this.useRelativePath) + attachmentFolder = Path.join(mdFolderPath, this.getAttachmentFolderPath(mdFileName)); + else { + attachmentFolder = this.getAttachmentFolderPath(mdFileName); + } + return (0, import_obsidian.normalizePath)(attachmentFolder); + } + getPastedImageFileName(mdFileName) { + let datetime = (0, import_obsidian.moment)().format(this.settings.dateTimeFormat); + let name = new TemplateString(this.settings.pastedImageFileName).interpolate({ + filename: mdFileName, + date: datetime + }); + return name; + } + handlePaste(event, editor, view) { + return __async(this, null, function* () { + console.log("Handle Paste"); + let mdFileName = view.file.basename; + let mdFolderPath = Path.dirname(view.file.path); + let path = this.getAttachmentFolderPath(mdFileName); + let fullPath = this.getAttachmentFolderFullPath(mdFolderPath, mdFileName); + this.updateAttachmentFolderConfig(path); + let clipBoardData = event.clipboardData; + if (clipBoardData == null || clipBoardData.items == null) + return; + let clipBoardItems = clipBoardData.items; + if (!clipBoardData.getData("text/plain")) { + for (let i in clipBoardItems) { + if (!clipBoardItems.hasOwnProperty(i)) + continue; + let item = clipBoardItems[i]; + if (item.kind !== "file") + continue; + if (!(item.type === "image/png" || item.type === "image/jpeg")) + continue; + let pasteImage = item.getAsFile(); + if (!pasteImage) + continue; + let extension = ""; + item.type === "image/png" ? extension = "png" : item.type === "image/jpeg" && (extension = "jpeg"); + event.preventDefault(); + if (!(yield this.adapter.exists(fullPath))) + yield this.adapter.mkdir(fullPath); + let img = yield blobToArrayBuffer(pasteImage); + let name = this.getPastedImageFileName(mdFileName); + let imageFile = yield this.app.saveAttachment(name, extension, img); + let markdownLink = yield this.app.fileManager.generateMarkdownLink(imageFile, view.file.path); + markdownLink += "\n\n"; + editor.replaceSelection(markdownLink); + } + } + }); + } + handleDrop(event, editor, view) { + return __async(this, null, function* () { + console.log("Handle Drop"); + let mdFileName = view.file.basename; + let mdFolderPath = Path.dirname(view.file.path); + let path = this.getAttachmentFolderPath(mdFileName); + let fullPath = this.getAttachmentFolderFullPath(mdFolderPath, mdFileName); + if (!this.useRelativePath && !(yield this.adapter.exists(fullPath))) + yield this.app.vault.createFolder(fullPath); + this.updateAttachmentFolderConfig(path); + }); + } + handleFileOpen(file) { + return __async(this, null, function* () { + console.log("Handle File Open"); + if (file == null) { + console.log("No file open"); + return; + } + if (file.extension !== "md") + return; + let mdFileName = file.basename; + let path = this.getAttachmentFolderPath(mdFileName); + this.updateAttachmentFolderConfig(path); + }); + } + handleRename(newFile, oldFilePath) { + return __async(this, null, function* () { + var _a; + console.log("Handle Rename"); + if (newFile.extension !== "md") + return; + let newName = newFile.basename; + this.updateAttachmentFolderConfig(this.getAttachmentFolderPath(newName)); + if (!this.settings.autoRenameFolder) { + return; + } + let oldName = Path.basename(oldFilePath, ".md"); + let mdFolderPath = Path.dirname(newFile.path); + let oldMdFolderPath = Path.dirname(oldFilePath); + let oldAttachmentFolderPath = this.getAttachmentFolderFullPath(oldMdFolderPath, oldName); + let newAttachmentFolderPath = this.getAttachmentFolderFullPath(mdFolderPath, newName); + if ((yield this.adapter.exists(oldAttachmentFolderPath)) && oldAttachmentFolderPath !== newAttachmentFolderPath) { + let tfolder = this.app.vault.getAbstractFileByPath(oldAttachmentFolderPath); + if (tfolder == null) + return; + let newAttachmentParentFolderPath = Path.dirname(newAttachmentFolderPath); + if (!(yield this.adapter.exists(newAttachmentParentFolderPath))) { + yield this.app.vault.createFolder(newAttachmentParentFolderPath); + } + yield this.app.fileManager.renameFile(tfolder, newAttachmentFolderPath); + let oldAttachmentParentFolderPath = Path.dirname(oldAttachmentFolderPath); + let oldAttachmentParentFolderList = yield this.adapter.list(oldAttachmentParentFolderPath); + if (oldAttachmentParentFolderList.folders.length === 0 && oldAttachmentParentFolderList.files.length === 0) { + yield this.adapter.rmdir(oldAttachmentParentFolderPath, true); + } + } + if (!this.settings.autoRenameFiles) + return; + let embeds = (_a = this.app.metadataCache.getCache(newFile.path)) == null ? void 0 : _a.embeds; + if (!embeds) + return; + let files = []; + for (let embed of embeds) { + let link = embed.link; + if (link.endsWith(".png") || link.endsWith("jpeg")) + files.push(Path.basename(link)); + else + continue; + } + let attachmentFiles = yield this.adapter.list(newAttachmentFolderPath); + for (let file of attachmentFiles.files) { + console.log(file); + let filePath = file; + let fileName = Path.basename(filePath); + if (files.indexOf(fileName) > -1 && fileName.contains(oldName)) { + fileName = fileName.replace(oldName, newName); + let newFilePath = (0, import_obsidian.normalizePath)(Path.join(newAttachmentFolderPath, fileName)); + let tfile = this.app.vault.getAbstractFileByPath(filePath); + if (tfile == null) + continue; + yield this.app.fileManager.renameFile(tfile, newFilePath); + } else + continue; + } + }); + } +}; +var CustomAttachmentLocationSettingTab = class extends import_obsidian.PluginSettingTab { + constructor(app, plugin) { + super(app, plugin); + this.plugin = plugin; + } + display() { + let { containerEl } = this; + containerEl.empty(); + containerEl.createEl("h2", { text: "Custom Attachment Location" }); + let el = new import_obsidian.Setting(containerEl).setName("Location for New Attachments").setDesc('Start with "./" to use relative path. Available variables: ${filename}.(NOTE: DO NOT start with "/" or end with "/". )').addText((text) => text.setPlaceholder("./assets/${filename}").setValue(this.plugin.settings.attachmentFolderPath).onChange((value) => __async(this, null, function* () { + console.log("attachmentFolder: " + value); + value = (0, import_obsidian.normalizePath)(value); + console.log("normalized attachmentFolder: " + value); + this.plugin.settings.attachmentFolderPath = value; + if (value.startsWith("./")) + this.plugin.useRelativePath = true; + else + this.plugin.useRelativePath = false; + yield this.plugin.saveSettings(); + }))); + el.controlEl.addEventListener("change", () => { + this.display(); + }); + new import_obsidian.Setting(containerEl).setName("Pasted Image Name").setDesc("Available variables: ${filename}, ${date}.").addText((text) => text.setPlaceholder("image-${date}").setValue(this.plugin.settings.pastedImageFileName).onChange((value) => __async(this, null, function* () { + console.log("pastedImageFileName: " + value); + this.plugin.settings.pastedImageFileName = value; + yield this.plugin.saveSettings(); + }))); + new import_obsidian.Setting(containerEl).setName("Date Format").setDesc("YYYYMMDDHHmmssSSS").addMomentFormat((text) => text.setDefaultFormat("YYYYMMDDHHmmssSSS").setValue(this.plugin.settings.dateTimeFormat).onChange((value) => __async(this, null, function* () { + console.log("dateTimeFormat: " + value); + this.plugin.settings.dateTimeFormat = value || "YYYYMMDDHHmmssSSS"; + yield this.plugin.saveSettings(); + }))); + new import_obsidian.Setting(containerEl).setName("Automatically rename attachment folder").setDesc('When renaming md files, automatically rename attachment folder if folder name contains "${filename}".').addToggle((toggle) => toggle.setValue(this.plugin.settings.autoRenameFolder).onChange((value) => __async(this, null, function* () { + this.plugin.settings.autoRenameFolder = value; + this.display(); + yield this.plugin.saveSettings(); + }))); + if (this.plugin.settings.autoRenameFolder) + new import_obsidian.Setting(containerEl).setName("Automatically rename attachment files").setDesc('When renaming md files, automatically rename attachment files if file name contains "${filename}".').addToggle((toggle) => toggle.setValue(this.plugin.settings.autoRenameFiles).onChange((value) => __async(this, null, function* () { + this.plugin.settings.autoRenameFiles = value; + yield this.plugin.saveSettings(); + }))); + } +}; diff --git a/.obsidian/plugins/obsidian-custom-attachment-location/manifest.json b/.obsidian/plugins/obsidian-custom-attachment-location/manifest.json new file mode 100644 index 0000000..c19f805 --- /dev/null +++ b/.obsidian/plugins/obsidian-custom-attachment-location/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "obsidian-custom-attachment-location", + "name": "Custom Attachment Location", + "version": "0.0.9", + "minAppVersion": "0.12.17", + "description": "Customize attachment location with variables($filename, $data, etc) like typora.", + "author": "RainCat1998", + "authorUrl": "https://github.com/RainCat1998", + "isDesktopOnly": true +} diff --git a/.obsidian/plugins/obsidian-customer-attachment-location/data.json b/.obsidian/plugins/obsidian-customer-attachment-location/data.json new file mode 100644 index 0000000..7fcdef0 --- /dev/null +++ b/.obsidian/plugins/obsidian-customer-attachment-location/data.json @@ -0,0 +1,7 @@ +{ + "attachmentFolderPath": "./${filename}.assets", + "pastedImageFileName": "image-${date}", + "dateTimeFormat": "YYYYMMDDHHmmssSSS", + "autoRenameFolder": true, + "autoRenameFiles": true +} \ No newline at end of file diff --git a/.obsidian/plugins/obsidian-customer-attachment-location/main.js b/.obsidian/plugins/obsidian-customer-attachment-location/main.js new file mode 100644 index 0000000..92bfaa8 --- /dev/null +++ b/.obsidian/plugins/obsidian-customer-attachment-location/main.js @@ -0,0 +1,310 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ESBUILD +if you want to view the source, please visit the github repository of this plugin +*/ + +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __markAsModule = (target) => __defProp(target, "__esModule", { value: true }); +var __export = (target, all) => { + __markAsModule(target); + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __reExport = (target, module2, desc) => { + if (module2 && typeof module2 === "object" || typeof module2 === "function") { + for (let key of __getOwnPropNames(module2)) + if (!__hasOwnProp.call(target, key) && key !== "default") + __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable }); + } + return target; +}; +var __toModule = (module2) => { + return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2); +}; +var __async = (__this, __arguments, generator) => { + return new Promise((resolve, reject) => { + var fulfilled = (value) => { + try { + step(generator.next(value)); + } catch (e) { + reject(e); + } + }; + var rejected = (value) => { + try { + step(generator.throw(value)); + } catch (e) { + reject(e); + } + }; + var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected); + step((generator = generator.apply(__this, __arguments)).next()); + }); +}; + +// main.ts +__export(exports, { + default: () => CustomAttachmentLocation +}); +var import_obsidian = __toModule(require("obsidian")); +var Path = __toModule(require("path")); +var DEFAULT_SETTINGS = { + attachmentFolderPath: "./assets/${filename}", + pastedImageFileName: "image-${date}", + dateTimeFormat: "YYYYMMDDHHmmssSSS", + autoRenameFolder: true, + autoRenameFiles: false +}; +var originalSettings = { + attachmentFolderPath: "" +}; +var blobToArrayBuffer = (blob) => { + return new Promise((resolve) => { + const reader = new FileReader(); + reader.onloadend = () => resolve(reader.result); + reader.readAsArrayBuffer(blob); + }); +}; +var TemplateString = class extends String { + interpolate(params) { + const names = Object.keys(params); + const vals = Object.values(params); + return new Function(...names, `return \`${this}\`;`)(...vals); + } +}; +var CustomAttachmentLocation = class extends import_obsidian.Plugin { + constructor() { + super(...arguments); + this.useRelativePath = false; + } + onload() { + return __async(this, null, function* () { + console.log("loading plugin"); + this.adapter = this.app.vault.adapter; + yield this.loadSettings(); + this.backupConfigs(); + this.addSettingTab(new CustomAttachmentLocationSettingTab(this.app, this)); + this.registerEvent(this.app.workspace.on("editor-paste", this.handlePaste.bind(this))); + this.registerEvent(this.app.workspace.on("editor-drop", this.handleDrop.bind(this))); + this.registerEvent(this.app.workspace.on("file-open", this.handleFileOpen.bind(this))); + this.registerEvent(this.app.vault.on("rename", this.handleRename.bind(this))); + }); + } + onunload() { + console.log("unloading plugin"); + this.restoreConfigs(); + } + loadSettings() { + return __async(this, null, function* () { + this.settings = Object.assign({}, DEFAULT_SETTINGS, yield this.loadData()); + if (this.settings.attachmentFolderPath.startsWith("./")) + this.useRelativePath = true; + else + this.useRelativePath = false; + }); + } + saveSettings() { + return __async(this, null, function* () { + yield this.saveData(this.settings); + }); + } + backupConfigs() { + originalSettings.attachmentFolderPath = this.app.vault.getConfig("attachmentFolderPath"); + } + restoreConfigs() { + this.app.vault.setConfig("attachmentFolderPath", originalSettings.attachmentFolderPath); + } + updateAttachmentFolderConfig(path) { + this.app.vault.setConfig("attachmentFolderPath", path); + } + getAttachmentFolderPath(mdFileName) { + let path = new TemplateString(this.settings.attachmentFolderPath).interpolate({ + filename: mdFileName + }); + return path; + } + getAttachmentFolderFullPath(mdFolderPath, mdFileName) { + let attachmentFolder = ""; + if (this.useRelativePath) + attachmentFolder = Path.join(mdFolderPath, this.getAttachmentFolderPath(mdFileName)); + else { + attachmentFolder = this.getAttachmentFolderPath(mdFileName); + } + return (0, import_obsidian.normalizePath)(attachmentFolder); + } + getPastedImageFileName(mdFileName) { + let datetime = (0, import_obsidian.moment)().format(this.settings.dateTimeFormat); + let name = new TemplateString(this.settings.pastedImageFileName).interpolate({ + filename: mdFileName, + date: datetime + }); + return name; + } + handlePaste(event, editor, view) { + return __async(this, null, function* () { + console.log("Handle Paste"); + let mdFileName = view.file.basename; + let mdFolderPath = Path.dirname(view.file.path); + let path = this.getAttachmentFolderPath(mdFileName); + let fullPath = this.getAttachmentFolderFullPath(mdFolderPath, mdFileName); + this.updateAttachmentFolderConfig(path); + let clipBoardData = event.clipboardData; + let clipBoardItems = clipBoardData.items; + if (!clipBoardData.getData("text/plain")) { + for (let i in clipBoardItems) { + if (!clipBoardItems.hasOwnProperty(i)) + continue; + let item = clipBoardItems[i]; + if (item.kind !== "file") + continue; + if (!(item.type === "image/png" || item.type === "image/jpeg")) + continue; + let pasteImage = item.getAsFile(); + if (!pasteImage) + continue; + let extension = ""; + item.type === "image/png" ? extension = "png" : item.type === "image/jpeg" && (extension = "jpeg"); + event.preventDefault(); + if (!(yield this.adapter.exists(fullPath))) + yield this.adapter.mkdir(fullPath); + let img = yield blobToArrayBuffer(pasteImage); + let name = this.getPastedImageFileName(mdFileName); + let imageFile = yield this.app.saveAttachment(name, extension, img); + let markdownLink = yield this.app.fileManager.generateMarkdownLink(imageFile, view.file.path); + markdownLink += "\n\n"; + editor.replaceSelection(markdownLink); + } + } + }); + } + handleDrop(event, editor, view) { + return __async(this, null, function* () { + console.log("Handle Drop"); + let mdFileName = view.file.basename; + let mdFolderPath = Path.dirname(view.file.path); + let path = this.getAttachmentFolderPath(mdFileName); + let fullPath = this.getAttachmentFolderFullPath(mdFolderPath, mdFileName); + if (!this.useRelativePath && !(yield this.adapter.exists(fullPath))) + yield this.app.vault.createFolder(fullPath); + this.updateAttachmentFolderConfig(path); + }); + } + handleFileOpen(file) { + return __async(this, null, function* () { + console.log("Handle File Open"); + if (file == null) { + console.log("No file open"); + return; + } + let mdFileName = file.basename; + let path = this.getAttachmentFolderPath(mdFileName); + this.updateAttachmentFolderConfig(path); + }); + } + handleRename(newFile, oldFilePath) { + return __async(this, null, function* () { + var _a; + console.log("Handle Rename"); + if (!this.settings.autoRenameFolder || newFile.extension !== "md") + return; + let newName = newFile.basename; + let oldName = Path.basename(oldFilePath, ".md"); + let mdFolderPath = Path.dirname(newFile.path); + let oldMdFolderPath = Path.dirname(oldFilePath); + let oldAttachmentFolderPath = this.getAttachmentFolderFullPath(oldMdFolderPath, oldName); + let newAttachmentFolderPath = this.getAttachmentFolderFullPath(mdFolderPath, newName); + if ((yield this.adapter.exists(oldAttachmentFolderPath)) && oldAttachmentFolderPath !== newAttachmentFolderPath) { + let tfolder = this.app.vault.getAbstractFileByPath(oldAttachmentFolderPath); + if (tfolder == null) + return; + let newAttachmentParentFolderPath = Path.dirname(newAttachmentFolderPath); + if (!(yield this.adapter.exists(newAttachmentParentFolderPath))) { + yield this.app.vault.createFolder(newAttachmentParentFolderPath); + } + yield this.app.fileManager.renameFile(tfolder, newAttachmentFolderPath); + let oldAttachmentParentFolderPath = Path.dirname(oldAttachmentFolderPath); + let oldAttachmentParentFolderList = yield this.adapter.list(oldAttachmentParentFolderPath); + if (oldAttachmentParentFolderList.folders.length === 0 && oldAttachmentParentFolderList.files.length === 0) { + yield this.adapter.rmdir(oldAttachmentParentFolderPath, true); + } + this.updateAttachmentFolderConfig(this.getAttachmentFolderPath(newName)); + } + if (!this.settings.autoRenameFiles) + return; + let embeds = (_a = this.app.metadataCache.getCache(newFile.path)) == null ? void 0 : _a.embeds; + if (!embeds) + return; + let files = []; + for (let embed of embeds) { + let link = embed.link; + if (link.endsWith(".png") || link.endsWith("jpeg")) + files.push(Path.basename(link)); + else + continue; + } + let attachmentFiles = yield this.adapter.list(newAttachmentFolderPath); + for (let file of attachmentFiles.files) { + console.log(file); + let filePath = file; + let fileName = Path.basename(filePath); + if (files.indexOf(fileName) > -1 && fileName.contains(oldName)) { + fileName = fileName.replace(oldName, newName); + let newFilePath = (0, import_obsidian.normalizePath)(Path.join(newAttachmentFolderPath, fileName)); + let tfile = this.app.vault.getAbstractFileByPath(filePath); + yield this.app.fileManager.renameFile(tfile, newFilePath); + } else + continue; + } + }); + } +}; +var CustomAttachmentLocationSettingTab = class extends import_obsidian.PluginSettingTab { + constructor(app, plugin) { + super(app, plugin); + this.plugin = plugin; + } + display() { + let { containerEl } = this; + containerEl.empty(); + containerEl.createEl("h2", { text: "Custom Attachment Location" }); + let el = new import_obsidian.Setting(containerEl).setName("Location for New Attachments").setDesc('Start with "./" to use relative path. Available variables: ${filename}.(NOTE: DO NOT start with "/" or end with "/". )').addText((text) => text.setPlaceholder("./assets/${filename}").setValue(this.plugin.settings.attachmentFolderPath).onChange((value) => __async(this, null, function* () { + console.log("attachmentFolder: " + value); + value = (0, import_obsidian.normalizePath)(value); + console.log("normalized attachmentFolder: " + value); + this.plugin.settings.attachmentFolderPath = value; + if (value.startsWith("./")) + this.plugin.useRelativePath = true; + else + this.plugin.useRelativePath = false; + yield this.plugin.saveSettings(); + }))); + el.controlEl.addEventListener("change", () => { + this.display(); + }); + new import_obsidian.Setting(containerEl).setName("Pasted Image Name").setDesc("Available variables: ${filename}, ${date}.").addText((text) => text.setPlaceholder("image-${date}").setValue(this.plugin.settings.pastedImageFileName).onChange((value) => __async(this, null, function* () { + console.log("pastedImageFileName: " + value); + this.plugin.settings.pastedImageFileName = value; + yield this.plugin.saveSettings(); + }))); + new import_obsidian.Setting(containerEl).setName("Date Format").setDesc("YYYYMMDDHHmmssSSS").addMomentFormat((text) => text.setDefaultFormat("YYYYMMDDHHmmssSSS").setValue(this.plugin.settings.dateTimeFormat).onChange((value) => __async(this, null, function* () { + console.log("dateTimeFormat: " + value); + this.plugin.settings.dateTimeFormat = value || "YYYYMMDDHHmmssSSS"; + yield this.plugin.saveSettings(); + }))); + new import_obsidian.Setting(containerEl).setName("Automatically rename attachment folder").setDesc('When renaming md files, automatically rename attachment folder if folder name contains "${filename}".').addToggle((toggle) => toggle.setValue(this.plugin.settings.autoRenameFolder).onChange((value) => __async(this, null, function* () { + this.plugin.settings.autoRenameFolder = value; + this.display(); + yield this.plugin.saveSettings(); + }))); + if (this.plugin.settings.autoRenameFolder) + new import_obsidian.Setting(containerEl).setName("Automatically rename attachment files [Experimental]").setDesc('When renaming md files, automatically rename attachment files if file name contains "${filename}".').addToggle((toggle) => toggle.setValue(this.plugin.settings.autoRenameFiles).onChange((value) => __async(this, null, function* () { + this.plugin.settings.autoRenameFiles = value; + yield this.plugin.saveSettings(); + }))); + } +}; diff --git a/.obsidian/plugins/obsidian-customer-attachment-location/manifest.json b/.obsidian/plugins/obsidian-customer-attachment-location/manifest.json new file mode 100644 index 0000000..9c6597c --- /dev/null +++ b/.obsidian/plugins/obsidian-customer-attachment-location/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "obsidian-custom-attachment-location", + "name": "Custom Attachment Location", + "version": "0.0.8", + "minAppVersion": "0.12.17", + "description": "Customize attachment location with variables($filename, $data, etc) like typora.", + "author": "RainCat1998", + "authorUrl": "https://github.com/RainCat1998", + "isDesktopOnly": false +} diff --git a/.obsidian/plugins/obsidian-excalidraw-plugin/data.json b/.obsidian/plugins/obsidian-excalidraw-plugin/data.json new file mode 100644 index 0000000..f822d29 --- /dev/null +++ b/.obsidian/plugins/obsidian-excalidraw-plugin/data.json @@ -0,0 +1,78 @@ +{ + "folder": "Excalidraw", + "embedUseExcalidrawFolder": false, + "templateFilePath": "Excalidraw/Template.excalidraw", + "scriptFolderPath": "Excalidraw/Scripts", + "compress": false, + "autosave": true, + "autosaveInterval": 10000, + "drawingFilenamePrefix": "Drawing ", + "drawingEmbedPrefixWithFilename": true, + "drawingFilnameEmbedPostfix": " ", + "drawingFilenameDateTime": "YYYY-MM-DD HH.mm.ss", + "useExcalidrawExtension": true, + "displaySVGInPreview": true, + "displayExportedImageIfAvailable": false, + "previewMatchObsidianTheme": false, + "width": "400", + "isLeftHanded": false, + "matchTheme": false, + "matchThemeAlways": false, + "matchThemeTrigger": false, + "defaultMode": "normal", + "defaultPenMode": "never", + "zoomToFitOnResize": true, + "zoomToFitMaxLevel": 2, + "linkPrefix": "📍", + "urlPrefix": "🌐", + "hoverPreviewWithoutCTRL": false, + "linkOpacity": 1, + "openInAdjacentPane": false, + "openInMainWorkspace": true, + "showLinkBrackets": true, + "allowCtrlClick": true, + "forceWrap": false, + "pageTransclusionCharLimit": 200, + "wordWrappingDefault": 0, + "iframelyAllowed": true, + "pngExportScale": 1, + "exportWithTheme": true, + "exportWithBackground": true, + "exportPaddingSVG": 10, + "keepInSync": false, + "autoexportSVG": false, + "autoexportPNG": false, + "autoExportLightAndDark": false, + "autoexportExcalidraw": false, + "embedType": "excalidraw", + "embedWikiLink": true, + "syncExcalidraw": false, + "experimentalFileType": false, + "experimentalFileTag": "✏️", + "experimentalLivePreview": true, + "experimentalEnableFourthFont": false, + "experimantalFourthFont": "Virgil", + "fieldSuggester": true, + "compatibilityMode": false, + "drawingOpenCount": 0, + "library": "deprecated", + "library2": { + "type": "excalidrawlib", + "version": 2, + "source": "https://excalidraw.com", + "libraryItems": [] + }, + "imageElementNotice": true, + "mdSVGwidth": 500, + "mdSVGmaxHeight": 800, + "mdFont": "Virgil", + "mdFontColor": "Black", + "mdBorderColor": "Black", + "mdCSS": "", + "scriptEngineSettings": {}, + "defaultTrayMode": false, + "previousRelease": "1.7.18", + "showReleaseNotes": true, + "showNewVersionNotification": true, + "mathjaxSourceURL": "https://cdn.jsdelivr.net/npm/mathjax@3.2.1/es5/tex-svg.js" +} \ No newline at end of file diff --git a/.obsidian/plugins/obsidian-excalidraw-plugin/main.js b/.obsidian/plugins/obsidian-excalidraw-plugin/main.js new file mode 100644 index 0000000..08fa152 --- /dev/null +++ b/.obsidian/plugins/obsidian-excalidraw-plugin/main.js @@ -0,0 +1,21 @@ +"use strict";var obsidian_module=require("obsidian");var LZString=function(){function o(o,r){if(!t[o]){t[o]={};for(var n=0;ne;e++){var s=r.charCodeAt(e);n[2*e]=s>>>8,n[2*e+1]=s%256}return n},decompressFromUint8Array:function(o){if(null===o||void 0===o)return i.decompress(o);for(var n=new Array(o.length/2),e=0,t=n.length;t>e;e++)n[e]=256*o[2*e]+o[2*e+1];var s=[];return n.forEach(function(o){s.push(r(o))}),i.decompress(s.join(""))},compressToEncodedURIComponent:function(o){return null==o?"":i._compress(o,6,function(o){return e.charAt(o)})},decompressFromEncodedURIComponent:function(r){return null==r?"":""==r?null:(r=r.replace(/ /g,"+"),i._decompress(r.length,32,function(n){return o(e,r.charAt(n))}))},compress:function(o){return i._compress(o,16,function(o){return r(o)})},_compress:function(o,r,n){if(null==o)return"";var e,t,i,s={},p={},u="",c="",a="",l=2,f=3,h=2,d=[],m=0,v=0;for(i=0;ie;e++)m<<=1,v==r-1?(v=0,d.push(n(m)),m=0):v++;for(t=a.charCodeAt(0),e=0;8>e;e++)m=m<<1|1&t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t>>=1}else{for(t=1,e=0;h>e;e++)m=m<<1|t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t=0;for(t=a.charCodeAt(0),e=0;16>e;e++)m=m<<1|1&t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t>>=1}l--,0==l&&(l=Math.pow(2,h),h++),delete p[a]}else for(t=s[a],e=0;h>e;e++)m=m<<1|1&t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t>>=1;l--,0==l&&(l=Math.pow(2,h),h++),s[c]=f++,a=String(u)}if(""!==a){if(Object.prototype.hasOwnProperty.call(p,a)){if(a.charCodeAt(0)<256){for(e=0;h>e;e++)m<<=1,v==r-1?(v=0,d.push(n(m)),m=0):v++;for(t=a.charCodeAt(0),e=0;8>e;e++)m=m<<1|1&t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t>>=1}else{for(t=1,e=0;h>e;e++)m=m<<1|t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t=0;for(t=a.charCodeAt(0),e=0;16>e;e++)m=m<<1|1&t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t>>=1}l--,0==l&&(l=Math.pow(2,h),h++),delete p[a]}else for(t=s[a],e=0;h>e;e++)m=m<<1|1&t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t>>=1;l--,0==l&&(l=Math.pow(2,h),h++)}for(t=2,e=0;h>e;e++)m=m<<1|1&t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t>>=1;for(;;){if(m<<=1,v==r-1){d.push(n(m));break}v++}return d.join("")},decompress:function(o){return null==o?"":""==o?null:i._decompress(o.length,32768,function(r){return o.charCodeAt(r)})},_decompress:function(o,n,e){var t,i,s,p,u,c,a,l,f=[],h=4,d=4,m=3,v="",w=[],A={val:e(0),position:n,index:1};for(i=0;3>i;i+=1)f[i]=i;for(p=0,c=Math.pow(2,2),a=1;a!=c;)u=A.val&A.position,A.position>>=1,0==A.position&&(A.position=n,A.val=e(A.index++)),p|=(u>0?1:0)*a,a<<=1;switch(t=p){case 0:for(p=0,c=Math.pow(2,8),a=1;a!=c;)u=A.val&A.position,A.position>>=1,0==A.position&&(A.position=n,A.val=e(A.index++)),p|=(u>0?1:0)*a,a<<=1;l=r(p);break;case 1:for(p=0,c=Math.pow(2,16),a=1;a!=c;)u=A.val&A.position,A.position>>=1,0==A.position&&(A.position=n,A.val=e(A.index++)),p|=(u>0?1:0)*a,a<<=1;l=r(p);break;case 2:return""}for(f[3]=l,s=l,w.push(l);;){if(A.index>o)return"";for(p=0,c=Math.pow(2,m),a=1;a!=c;)u=A.val&A.position,A.position>>=1,0==A.position&&(A.position=n,A.val=e(A.index++)),p|=(u>0?1:0)*a,a<<=1;switch(l=p){case 0:for(p=0,c=Math.pow(2,8),a=1;a!=c;)u=A.val&A.position,A.position>>=1,0==A.position&&(A.position=n,A.val=e(A.index++)),p|=(u>0?1:0)*a,a<<=1;f[d++]=r(p),l=d-1,h--;break;case 1:for(p=0,c=Math.pow(2,16),a=1;a!=c;)u=A.val&A.position,A.position>>=1,0==A.position&&(A.position=n,A.val=e(A.index++)),p|=(u>0?1:0)*a,a<<=1;f[d++]=r(p),l=d-1,h--;break;case 2:return w.join("")}if(0==h&&(h=Math.pow(2,m),m++),f[l])v=f[l];else{if(l!==d)return null;v=s+s.charAt(0)}w.push(v),f[d++]=s+v.charAt(0),h--,s=v,0==h&&(h=Math.pow(2,m),m++)}}};return i}();"function"==typeof define&&define.amd?define(function(){return LZString}):"undefined"!=typeof module&&null!=module&&(module.exports=LZString); +const EXCALIDRAW_PACKAGES = "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";const {react, reactDOM, excalidrawLib} = window.eval.call(window, `(function() {${LZString.decompressFromBase64(EXCALIDRAW_PACKAGES)};return {react:React, reactDOM:ReactDOM, excalidrawLib: ExcalidrawLib};})();`);const PLUGIN_VERSION="1.9.10";function _interopNamespace(e){if(e&&e.__esModule)return e;var t=Object.create(null);return e&&Object.keys(e).forEach((function(A){if("default"!==A){var i=Object.getOwnPropertyDescriptor(e,A);Object.defineProperty(t,A,i.get?i:{enumerable:!0,get:function(){return e[A]}})}})),t.default=e,Object.freeze(t)}var obsidian_module__namespace=_interopNamespace(obsidian_module),React__namespace=_interopNamespace(React);let random$1=e=>crypto.getRandomValues(new Uint8Array(e)),customRandom=(e,t,A)=>{let i=(2<{let r="";for(;;){let t=A(n),s=n;for(;s--;)if(r+=e[t[s]&i]||"",r.length===a)return r}}},customAlphabet=(e,t=21)=>customRandom(e,t,random$1),nanoid$1=(e=21)=>crypto.getRandomValues(new Uint8Array(e)).reduce(((e,t)=>e+((t&=63)<36?t.toString(36):t<62?(t-26).toString(36).toUpperCase():t>62?"-":"_")),"");const ERROR_IFRAME_CONVERSION_CANCELED="iframe conversion canceled",{sceneCoordsToViewportCoords:sceneCoordsToViewportCoords,viewportCoordsToSceneCoords:viewportCoordsToSceneCoords,determineFocusDistance:determineFocusDistance,intersectElementWithLine:intersectElementWithLine,getCommonBoundingBox:getCommonBoundingBox,getMaximumGroups:getMaximumGroups,measureText:measureText,getDefaultLineHeight:getDefaultLineHeight,wrapText:wrapText,getFontString:getFontString,getBoundTextMaxWidth:getBoundTextMaxWidth,exportToSvg:exportToSvg,exportToBlob:exportToBlob,mutateElement:mutateElement}=excalidrawLib;function JSON_parse(e){return JSON.parse(e.replaceAll("[","["))}/Mac|iPod|iPhone|iPad/.test(window.navigator.platform);const DEVICE={isDesktop:!document.body.hasClass("is-tablet")&&!document.body.hasClass("is-mobile"),isPhone:document.body.hasClass("is-phone"),isTablet:document.body.hasClass("is-tablet"),isMobile:document.body.hasClass("is-mobile"),isLinux:document.body.hasClass("mod-linux")&&!document.body.hasClass("is-android"),isMacOS:document.body.hasClass("mod-macos")&&!document.body.hasClass("is-ios"),isWindows:document.body.hasClass("mod-windows"),isIOS:document.body.hasClass("is-ios"),isAndroid:document.body.hasClass("is-android")},ROOTELEMENTSIZE=(()=>{const e=document.createElement("div");e.style.fontSize="1rem",e.style.display="none",document.body.appendChild(e);const t=getComputedStyle(e),A=parseFloat(t.fontSize);return document.body.removeChild(e),A})(),nanoid=customAlphabet("1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",8),KEYCODE={ESC:27},ROUNDNESS={LEGACY:1,PROPORTIONAL_RADIUS:2,ADAPTIVE_RADIUS:3},GITHUB_RELEASES="https://github.com/zsviczian/obsidian-excalidraw-plugin/releases/tag/",URLFETCHTIMEOUT=3e3,PLUGIN_ID="obsidian-excalidraw-plugin",SCRIPT_INSTALL_CODEBLOCK="excalidraw-script-install",SCRIPT_INSTALL_FOLDER="Downloaded",fileid=customAlphabet("1234567890abcdef",40),REG_LINKINDEX_INVALIDCHARS=/[<>:"\\|?*#]/g,REG_BLOCK_REF_CLEAN=/[!"#$%&()*+,.:;<=>?@^`{|}~\/\[\]\\]/g,IMAGE_TYPES=["jpeg","jpg","png","gif","svg","webp","bmp","ico"],EXPORT_TYPES=["svg","dark.svg","light.svg","png","dark.png","light.png"],MAX_IMAGE_SIZE=500,FRONTMATTER_KEY="excalidraw-plugin",FRONTMATTER_KEY_EXPORT_TRANSPARENT="excalidraw-export-transparent",FRONTMATTER_KEY_EXPORT_DARK="excalidraw-export-dark",FRONTMATTER_KEY_EXPORT_SVGPADDING="excalidraw-export-svgpadding",FRONTMATTER_KEY_EXPORT_PADDING="excalidraw-export-padding",FRONTMATTER_KEY_EXPORT_PNGSCALE="excalidraw-export-pngscale",FRONTMATTER_KEY_CUSTOM_PREFIX="excalidraw-link-prefix",FRONTMATTER_KEY_CUSTOM_URL_PREFIX="excalidraw-url-prefix",FRONTMATTER_KEY_CUSTOM_LINK_BRACKETS="excalidraw-link-brackets",FRONTMATTER_KEY_ONLOAD_SCRIPT="excalidraw-onload-script",FRONTMATTER_KEY_LINKBUTTON_OPACITY="excalidraw-linkbutton-opacity",FRONTMATTER_KEY_DEFAULT_MODE="excalidraw-default-mode",FRONTMATTER_KEY_FONT="excalidraw-font",FRONTMATTER_KEY_FONTCOLOR="excalidraw-font-color",FRONTMATTER_KEY_BORDERCOLOR="excalidraw-border-color",FRONTMATTER_KEY_MD_STYLE="excalidraw-css",FRONTMATTER_KEY_AUTOEXPORT="excalidraw-autoexport",FRONTMATTER_KEY_EMBEDDABLE_THEME="excalidraw-iframe-theme",EMBEDDABLE_THEME_FRONTMATTER_VALUES=["light","dark","auto","dafault"],VIEW_TYPE_EXCALIDRAW="excalidraw",ICON_NAME="excalidraw-icon",RERENDER_EVENT="excalidraw-embed-rerender",BLANK_DRAWING=`{"type":"excalidraw","version":2,"source":"${GITHUB_RELEASES+PLUGIN_VERSION}","elements":[],"appState":{"gridSize":null,"viewBackgroundColor":"#ffffff"}}`,DARK_BLANK_DRAWING=`{"type":"excalidraw","version":2,"source":"${GITHUB_RELEASES+PLUGIN_VERSION}","elements":[],"appState":{"theme":"dark","gridSize":null,"viewBackgroundColor":"#ffffff"}}`,FRONTMATTER=["---","","excalidraw-plugin: parsed","tags: [excalidraw]","","---","==⚠ Switch to EXCALIDRAW VIEW in the MORE OPTIONS menu of this document. ⚠==","",""].join("\n"),EMPTY_MESSAGE="Hit enter to create a new drawing",TEXT_DISPLAY_PARSED_ICON_NAME="quote-glyph",TEXT_DISPLAY_RAW_ICON_NAME="presentation",FULLSCREEN_ICON_NAME="fullscreen",SCRIPTENGINE_ICON_NAME="ScriptEngine",KEYBOARD_EVENT_TYPES=["keydown","keyup","keypress"],EXTENDED_EVENT_TYPES=["copy","cut","paste"],COLOR_NAMES=new Map;COLOR_NAMES.set("aliceblue","#f0f8ff"),COLOR_NAMES.set("antiquewhite","#faebd7"),COLOR_NAMES.set("aqua","#00ffff"),COLOR_NAMES.set("aquamarine","#7fffd4"),COLOR_NAMES.set("azure","#f0ffff"),COLOR_NAMES.set("beige","#f5f5dc"),COLOR_NAMES.set("bisque","#ffe4c4"),COLOR_NAMES.set("black","#000000"),COLOR_NAMES.set("blanchedalmond","#ffebcd"),COLOR_NAMES.set("blue","#0000ff"),COLOR_NAMES.set("blueviolet","#8a2be2"),COLOR_NAMES.set("brown","#a52a2a"),COLOR_NAMES.set("burlywood","#deb887"),COLOR_NAMES.set("cadetblue","#5f9ea0"),COLOR_NAMES.set("chartreuse","#7fff00"),COLOR_NAMES.set("chocolate","#d2691e"),COLOR_NAMES.set("coral","#ff7f50"),COLOR_NAMES.set("cornflowerblue","#6495ed"),COLOR_NAMES.set("cornsilk","#fff8dc"),COLOR_NAMES.set("crimson","#dc143c"),COLOR_NAMES.set("cyan","#00ffff"),COLOR_NAMES.set("darkblue","#00008b"),COLOR_NAMES.set("darkcyan","#008b8b"),COLOR_NAMES.set("darkgoldenrod","#b8860b"),COLOR_NAMES.set("darkgray","#a9a9a9"),COLOR_NAMES.set("darkgreen","#006400"),COLOR_NAMES.set("darkkhaki","#bdb76b"),COLOR_NAMES.set("darkmagenta","#8b008b"),COLOR_NAMES.set("darkolivegreen","#556b2f"),COLOR_NAMES.set("darkorange","#ff8c00"),COLOR_NAMES.set("darkorchid","#9932cc"),COLOR_NAMES.set("darkred","#8b0000"),COLOR_NAMES.set("darksalmon","#e9967a"),COLOR_NAMES.set("darkseagreen","#8fbc8f"),COLOR_NAMES.set("darkslateblue","#483d8b"),COLOR_NAMES.set("darkslategray","#2f4f4f"),COLOR_NAMES.set("darkturquoise","#00ced1"),COLOR_NAMES.set("darkviolet","#9400d3"),COLOR_NAMES.set("deeppink","#ff1493"),COLOR_NAMES.set("deepskyblue","#00bfff"),COLOR_NAMES.set("dimgray","#696969"),COLOR_NAMES.set("dodgerblue","#1e90ff"),COLOR_NAMES.set("firebrick","#b22222"),COLOR_NAMES.set("floralwhite","#fffaf0"),COLOR_NAMES.set("forestgreen","#228b22"),COLOR_NAMES.set("fuchsia","#ff00ff"),COLOR_NAMES.set("gainsboro","#dcdcdc"),COLOR_NAMES.set("ghostwhite","#f8f8ff"),COLOR_NAMES.set("gold","#ffd700"),COLOR_NAMES.set("goldenrod","#daa520"),COLOR_NAMES.set("gray","#808080"),COLOR_NAMES.set("green","#008000"),COLOR_NAMES.set("greenyellow","#adff2f"),COLOR_NAMES.set("honeydew","#f0fff0"),COLOR_NAMES.set("hotpink","#ff69b4"),COLOR_NAMES.set("indianred","#cd5c5c"),COLOR_NAMES.set("indigo","#4b0082"),COLOR_NAMES.set("ivory","#fffff0"),COLOR_NAMES.set("khaki","#f0e68c"),COLOR_NAMES.set("lavender","#e6e6fa"),COLOR_NAMES.set("lavenderblush","#fff0f5"),COLOR_NAMES.set("lawngreen","#7cfc00"),COLOR_NAMES.set("lemonchiffon","#fffacd"),COLOR_NAMES.set("lightblue","#add8e6"),COLOR_NAMES.set("lightcoral","#f08080"),COLOR_NAMES.set("lightcyan","#e0ffff"),COLOR_NAMES.set("lightgoldenrodyellow","#fafad2"),COLOR_NAMES.set("lightgrey","#d3d3d3"),COLOR_NAMES.set("lightgreen","#90ee90"),COLOR_NAMES.set("lightpink","#ffb6c1"),COLOR_NAMES.set("lightsalmon","#ffa07a"),COLOR_NAMES.set("lightseagreen","#20b2aa"),COLOR_NAMES.set("lightskyblue","#87cefa"),COLOR_NAMES.set("lightslategray","#778899"),COLOR_NAMES.set("lightsteelblue","#b0c4de"),COLOR_NAMES.set("lightyellow","#ffffe0"),COLOR_NAMES.set("lime","#00ff00"),COLOR_NAMES.set("limegreen","#32cd32"),COLOR_NAMES.set("linen","#faf0e6"),COLOR_NAMES.set("magenta","#ff00ff"),COLOR_NAMES.set("maroon","#800000"),COLOR_NAMES.set("mediumaquamarine","#66cdaa"),COLOR_NAMES.set("mediumblue","#0000cd"),COLOR_NAMES.set("mediumorchid","#ba55d3"),COLOR_NAMES.set("mediumpurple","#9370d8"),COLOR_NAMES.set("mediumseagreen","#3cb371"),COLOR_NAMES.set("mediumslateblue","#7b68ee"),COLOR_NAMES.set("mediumspringgreen","#00fa9a"),COLOR_NAMES.set("mediumturquoise","#48d1cc"),COLOR_NAMES.set("mediumvioletred","#c71585"),COLOR_NAMES.set("midnightblue","#191970"),COLOR_NAMES.set("mintcream","#f5fffa"),COLOR_NAMES.set("mistyrose","#ffe4e1"),COLOR_NAMES.set("moccasin","#ffe4b5"),COLOR_NAMES.set("navajowhite","#ffdead"),COLOR_NAMES.set("navy","#000080"),COLOR_NAMES.set("oldlace","#fdf5e6"),COLOR_NAMES.set("olive","#808000"),COLOR_NAMES.set("olivedrab","#6b8e23"),COLOR_NAMES.set("orange","#ffa500"),COLOR_NAMES.set("orangered","#ff4500"),COLOR_NAMES.set("orchid","#da70d6"),COLOR_NAMES.set("palegoldenrod","#eee8aa"),COLOR_NAMES.set("palegreen","#98fb98"),COLOR_NAMES.set("paleturquoise","#afeeee"),COLOR_NAMES.set("palevioletred","#d87093"),COLOR_NAMES.set("papayawhip","#ffefd5"),COLOR_NAMES.set("peachpuff","#ffdab9"),COLOR_NAMES.set("peru","#cd853f"),COLOR_NAMES.set("pink","#ffc0cb"),COLOR_NAMES.set("plum","#dda0dd"),COLOR_NAMES.set("powderblue","#b0e0e6"),COLOR_NAMES.set("purple","#800080"),COLOR_NAMES.set("rebeccapurple","#663399"),COLOR_NAMES.set("red","#ff0000"),COLOR_NAMES.set("rosybrown","#bc8f8f"),COLOR_NAMES.set("royalblue","#4169e1"),COLOR_NAMES.set("saddlebrown","#8b4513"),COLOR_NAMES.set("salmon","#fa8072"),COLOR_NAMES.set("sandybrown","#f4a460"),COLOR_NAMES.set("seagreen","#2e8b57"),COLOR_NAMES.set("seashell","#fff5ee"),COLOR_NAMES.set("sienna","#a0522d"),COLOR_NAMES.set("silver","#c0c0c0"),COLOR_NAMES.set("skyblue","#87ceeb"),COLOR_NAMES.set("slateblue","#6a5acd"),COLOR_NAMES.set("slategray","#708090"),COLOR_NAMES.set("snow","#fffafa"),COLOR_NAMES.set("springgreen","#00ff7f"),COLOR_NAMES.set("steelblue","#4682b4"),COLOR_NAMES.set("tan","#d2b48c"),COLOR_NAMES.set("teal","#008080"),COLOR_NAMES.set("thistle","#d8bfd8"),COLOR_NAMES.set("tomato","#ff6347"),COLOR_NAMES.set("turquoise","#40e0d0"),COLOR_NAMES.set("violet","#ee82ee"),COLOR_NAMES.set("wheat","#f5deb3"),COLOR_NAMES.set("white","#ffffff"),COLOR_NAMES.set("whitesmoke","#f5f5f5"),COLOR_NAMES.set("yellow","#ffff00"),COLOR_NAMES.set("yellowgreen","#9acd32");const DEFAULT_MD_EMBED_CSS='.snw-reference{display: none;}.excalidraw-md-host{padding:0px 10px}.excalidraw-md-footer{height:5px}foreignObject{background-color:transparent}p{display:block;margin-block-start:1em;margin-block-end:1em;margin-inline-start:0px;margin-inline-end:0px;color:inherit}table,tr,th,td{color:inherit;border:1px solid;border-collapse:collapse;padding:3px}th{font-weight:bold;border-bottom:double;background-color:silver}.copy-code-button{display:none}code[class*=language-],pre[class*=language-]{color:#393a34;font-family:"Consolas","Bitstream Vera Sans Mono","Courier New",Courier,monospace;direction:ltr;text-align:left;white-space:pre;word-spacing:normal;word-break:normal;font-size:.9em;line-height:1.2em;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-hyphens:none;-moz-hyphens:none;-ms-hyphens:none;hyphens:none}pre>code[class*=language-]{font-size:1em}pre[class*=language-]::-moz-selection,pre[class*=language-] ::-moz-selection,code[class*=language-]::-moz-selection,code[class*=language-] ::-moz-selection{background:#C1DEF1}pre[class*=language-]::selection,pre[class*=language-] ::selection,code[class*=language-]::selection,code[class*=language-] ::selection{background:#C1DEF1}pre[class*=language-]{padding:1em;margin:.5em 0;overflow:auto;background-color:#0000001a}:not(pre)>code[class*=language-]{padding:.2em;padding-top:1px;padding-bottom:1px;background:#f8f8f8;border:1px solid #dddddd}.token.comment,.token.prolog,.token.doctype,.token.cdata{color:green;font-style:italic}.token.namespace{opacity:.7}.token.string{color:#a31515}.token.punctuation,.token.operator{color:#393a34}.token.url,.token.symbol,.token.number,.token.boolean,.token.variable,.token.constant,.token.inserted{color:#36acaa}.token.atrule,.token.keyword,.token.attr-value,.language-autohotkey .token.selector,.language-json .token.boolean,.language-json .token.number,code[class*=language-css]{color:#00f}.token.function{color:#393a34}.token.deleted,.language-autohotkey .token.tag{color:#9a050f}.token.selector,.language-autohotkey .token.keyword{color:#00009f}.token.important{color:#e90}.token.important,.token.bold{font-weight:bold}.token.italic{font-style:italic}.token.class-name,.language-json .token.property{color:#2b91af}.token.tag,.token.selector{color:maroon}.token.attr-name,.token.property,.token.regex,.token.entity{color:red}.token.directive.tag .tag{background:#ffff00;color:#393a34}.line-numbers.line-numbers .line-numbers-rows{border-right-color:#a5a5a5}.line-numbers .line-numbers-rows>span:before{color:#2b91af}.line-highlight.line-highlight{background:rgba(193,222,241,.2);background:-webkit-linear-gradient(left,rgba(193,222,241,.2) 70%,rgba(221,222,241,0));background:linear-gradient(to right,rgba(193,222,241,.2) 70%,rgba(221,222,241,0))}blockquote{ font-style:italic;background-color:rgb(46,43,42,0.1);margin:0;margin-left:1em;border-radius:0 4px 4px 0;border:1px solid hsl(0,80%,32%);border-left-width:8px;border-top-width:0px;border-right-width:0px;border-bottom-width:0px;padding:10px 20px;margin-inline-start:30px;margin-inline-end:30px;}',SCRIPTENGINE_ICON='',DISK_ICON_NAME="save",EXPORT_IMG_ICON=' ',EXPORT_IMG_ICON_NAME="export-img",EXCALIDRAW_ICON='',VIRGIL_DATAURL="data:application/font-woff;charset=utf-8;base64,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",VIRGIL_FONT=` @font-face {font-family: "Virgil";src: url("${VIRGIL_DATAURL}") format("woff2");}`,CASCADIA_FONT=' @font-face {font-family: "Cascadia";src: url("data:application/font-woff;charset=utf-8;base64,d09GRgABAAAAAVMcABEAAAADQeQHdzXDAAAAAAAAAAAAAAAAAAAAAAAAAABHREVGAAABgAAAATAAAAG8nuKcikdQT1MAAAKwAAAHlwAAFlLMTxXFR1NVQgAACkgAACXhAABRIFkPGxpPUy8yAAAwLAAAAF4AAABgbEt/gWNtYXAAADCMAAAKPgAADSZvLoOeY3Z0IAAAOswAAADjAAABFlZAOwxmcGdtAAA7sAAACBUAAA+DV4sPEGdhc3AAAEPIAAAAEAAAABAAOwAmZ2x5ZgAAQ9gAAMcWAAH9uFaLzNxoZWFkAAEK8AAAADYAAAA2EapGVWhoZWEAAQsoAAAAIQAAACQABASPaG10eAABC0wAAAUuAAAYLrBaWdJsb2NhAAEQfAAADBoAAAwaQSrAaW1heHAAARyYAAAAIAAAACAJshCbbmFtZQABHLgAAAfUAAAZ3FI4deJwb3N0AAEkjAAALIQAAHpUjVe9UXByZXAAAVEQAAACCgAAArOJYnqCeJwd0c9Hw3Ecx/H36/3Z99uatl1SikmZlNGtJDPrh5126Jj6L6JDt0liIh2SDunepVNGTDqMItEhSWmmS4cOnWaHRE99+Dx8Dm9eH6+3ydwy9n90xnvJZIvcZdvDul1iw96wrYRJsZKYUhqzGsWc5nFBK1jRJm5pG2uq4Y52cFe7WNc+HugQj3SMJzrFM5Klc11gQ1fYVBOvdYMttfBWd3ivB3zUE77oBV/F3/SuNnbUwS99Y1dd7KmHP/rBX3eTRx5h0lOY9gwO+TCO+hiO+wTmPY+TPolTPo0FL+CMz+Csz2HRi1jyEpa9jBWvYNWruOpruO4bpuCBxNAX6C0MBHoL2ZDFwUBuyAVyo+fo00LUjWUhDnECk3G/BVoXi0myl8DMhxkzZun/mZE/IhM7bnicvVh9bFRFEJ/Zd+9aa+m9d9doRT4qIQ0KNg1BQxpCEJpqtFRSiLmgNopVtBykQb0gElMbbcrZACEVEZv6RQgQbNAYCgQJKn5ElKAhiICkIYhGDRqjaBDQ2dl5r3dbyBX+4DY7v5nZ2dl9s7N7+x4gABRBIywBp6a2bg6UPvLM4hSUpR5+ahGMg9updSKo6Xc2lMPE2Q3TicIYcGfcMaccxsy8t45ofV0N0Vl19xBtuHcmUYD//gNFPRHUwocXL4CShQsWLoBS1gBTaoFo6WMQYamQajH1i+A6NYFaHPeQ+yOA+1cUIR51ohEYTdqpZHUH2c+AdsLl8D68CNvgKLwLxzEC32IUC+ECFuEwRIzhcHRxJE5GH6uxBm/FWlxM0tP4DD6KrVSasY3KAnyBSgqX40u4EFfgKmzBLlyDT+JafA3T2ENlKW7CXnwWt+EOfB53UXkRd+MebMe9VJbjZ/g5ZnAffoWdeAAP4ko8TKULj+BRfBm/x+P4CvZTeRV/wd9wHf5F5XX8m8ob+C+VN/G8UviWcpWLG1WhKsJNapgqwS3qOnU99qrhajRuVTepMbhNjVVjcbuqUBW4Q41TN+NONV6Nx12qUlXiB+o2dTvuVlPUFNyjpqqp+KGapqbhR6pW1eLHqk7V4V41SyXxEzVX3Y/7HeW4eMApcArxoFPsDMNDTsyJ4WGn1Lkev3NGOqPxe7gJILGUaivVdqqbqXZSXW3VHsG1zCOtkYpvl9oMDug+W4dQ14c8+j0yHvHqZGQs0X1QhP2JUQDxCr87xBWXiW2XifZ4+bDLQtHH5hGWDGCcdkR8OID/DdXDAxhTllwoWCKo+9yVhaW5sp+husrvDjBWLlghOOHyMPQzMVceMp4hPEfPSs8Vp2eJTRacKlhjMGy/26CJWxa2ZcsXWX97vZZd2fr5xWac2Kys8UoGMHafvyb2wNBx0HME2HEJ/SD015j5Ca4QbLtMtP1cZTR5T1XyPsCgXcv+caPXGHs8V9bxyMEOS24bbBcvz8IOSw4xT3yvVpy6bP0l8qFtqHlzhfb58nWZweB8GpynWfHX+qicf4sEjwg+ZclLLTnAU4KtltxuyQF2yn4Oxu235NWWvFawJ1efADN/75icB+tN/vqfUv2S5H8MekUGA70XkfbNoj/p/+z/noWj5DzdKrhNzsmxIn8uuMuSP7JkQf8WkfeLPCrXXzjeQatdMFFG+BDNO011mVkvfzHN/4hgv+Apg2H7rwb9OZIPgrE/DOqfP1fiMpfG/0fwgkGOE6FfbzCw53hqvfTzvNz2UH8d2dJt0xshOI5qZRZO8qrZ3xAxWO+EnP9+lSUvyZVDBP99yped3jGDiWbBRtFPs+TaXDlAv1dk8ZdosmR7nHx2dSKnh+bHazD7NszjJOHvJi5eo9kHGhNNgqL3p5h+XpNgs/gJ9C2WLHnmtXkd3or8mCj2n/NfoHyoMuh1CW4X3G0wtFuSK9v989l56wTfsPQbLHkLzfE9kwd6/+h84X20XXC36JcYDPLLp7cqP0XtewW/EDxgMGw/lCv7j+XK9vmk14XlE4I/yTqeFvmsrPOfsg5nB/YpacJ7VXgvvcR9LjjXIdgvee4t9j03+N/148ZHdj/Ok+A+HA3uBxe/nw3tfyv7f9TMJxxXznl/j0SgTNA+P+V8TUikQmwSLJZ+VUG77OdPc/8XwnW01i/YF6HddOB7fHjeyfkYzDMYL+wfnL9yLgbneSJtzUfyJzi/B+2PcD8E51puHO28uPQ9NSvuJfnzIuc+Zq3fQH4MjGfHwd+Y+5zZ68T20u6/ZduL3Guta5afi4036L0tWLes/Ob1DP7vrfcfOy72fThfXOg9+MOCKk2jB5mfTLSCNRVuJ9F0dL+mrEmzTZpt+ljfx/o+1vdpvVOseYxw3xT7b2W+ii1rog2aFhxl+gPZbyrYQHRjgX4vr3VPaL3bzZaNbNNM3sqi5cR3cGuKPaTcd6jX19z3APdNuaeJNhsb40HbkJ8HmNet03Urxgv023+G/WTYJsOtGbbM6L5Oif5C4JRovVN8gUbHIp5DjX4iPOseI/0eph/wHHbxHDayh3n8dWGEptjLEUjzWGluTfNYJ7U3PMetSbcJMFLJvVaypp5n1cP29fws9RyNB9nmQbHRfmbx885n//NZ84RodN8k6+9jTSbawn5aeCYt3EoUJ4BLfFyvkVPMK5Vh2mrizCOm2Nsi9lNvxmJ9mmmFoTyrThNhHRnVY+bJdD5H9V3mR+h4kh/yGXmI+1abKJl803ykW/ORyVBEmuE8bhlbztV8xGM+ya2tzGcMNfnMft5mfp6mTo+OdqTbrAvru9imi/k+5veZXGVaZTKW+dlmjYhGwQOkMUG+MCLUwGn5wniCvzACDOMvjDeQ1iUt7Vu33+2Ha9wz7hkocs+65+FasnAgBjeSH3qHAXpvAXpXAR0tPXq7VVcLdgq/fgh1bRbfw0hZYOLHdDzTuIki0xqm9Yby01ebVuI9etYxMA4qYRJUwzSohTpogCQ0QhM0Qwuk2U6v0XjOk2rOkHkmAzknk8K/w3wj8zqrk3ySJPn0SPL5kORTJVmQYj8t/wM5o4LrAHicnXwNfJRHtffM7LNLSDYfJJuQQliSTcjH7uZrs0k2JIQkTSmlKfJiLi9yESmkiEhTDBQpRhoRub2YxogVESlFSilSihQRMUXESGmkiBgxUqQRKSIiIiJWRKT3PzNnn90ky2vv+3t+Z/Z5zs7M+c+ZM2fOmf1gnDEWzVssrcxSP6mhkTnmP9WymKUufnRZM1vCVuHdlUzUPTg9nSV8eHpdOvMz9v77LB58zgSzMINZmY3FsjjwEtgIlsiSmCNCHfuQOi5mvb+2MZ3VP/KhhnS2cGpDfTprn9bwcDrbO/1Dj6Sz06qXuAG9/Hs5wz5AnagPUGf4B6gT/QHqxAypk/zoo4uXsbb5snxm/qNLH+Od8+c/voRvaGp+4nG+ZUHLo/P59sVPzF/M96hyvyq7VHlElcdUeUKVvc1PPt7CzzzR0tTM+5d+onkBv7R0aZGPX126tLiC31j65Lyl/NbSJ5cs5XdXPtbyhDCATiiEjK3GnU2NIoEls1SWxsZiVrJZHvOyIlbCylgFq2ITWR17gE1mD7MPsensP9hM9p/sY2wee4x9nH2CLWbSTpayJ9kKWMpnWRv7PFvL1rF21sHWs+fY19g32AtsG9vBvsVeZXvZPvZd9j32ffY6+wE7wrrZUfYm+wl7i/2U/Yz9nP2C/ZL9ip1l51g/O88usN+x37M/sKvsGrvO/sr+xv7O/sH+ye5yxgU3uI1H8Whu53E8gSfxZD6S38dH8zF8LM/gWTyb53I3z+eFvJj7eRkP8Eo+gU/ktbyeP8gf4g/zR/g0/mGpC94itcJn8I+op0+gtPBF/JN8sXpuUuVcVc5R5cdU+VFVzlblfFUuVP08wT+lnhaocqkqn1TlY6r8uCqX8eXimpFqaxuW6BEeMSxr2AH12hPVUtwTtXZ4Ufn44VOHn59YJq/h16Ln5MyNXhITlbc1b2tMSsxaj4jZaE/zCHuBfX9hXWGdvTt2cmFd7KzYW8U9cdFxO4t78HogvrG4J35BglHck5CSsL80MeHYiKbK7hHLEx3FPYnZiUdR9iUtK1mT1JF0tzTRkeBoQ7k+ubo0sTQxuSH5EMqTKXhKmZZyBGXvyLry8SMbRx4tH4/X3tS6yu7UxtSjOXNT++6bdF/TfbvvOz5qqkeMmjvq1Khro8tGN44+W9wz+mpaS1rnmJTK7jG5YzaOOeDMLh/vDDh3VnY7u8a6K7vHVo3djfJw+qLK7sru9BXpR9L7M6ZmLM44J0eeccU1y7XCdbmuJlNkttTV4LUt8/r9q+5flXk3q7m4J6st6/qDPQ/2ZN0d1zy5atwz425l23CNyl6cvTK7I/tSDsuZnjM3pznnWM75XF9uQ+6W3IN50XlpeeuhyT1u5h7l7nRvc9+E7hM8yzwdnhteu3eOd4X3uPdi/uT8WflH8/sL6gpmF+wvOFnoh6anFR4oPFU0uWhW0ZGi3uKs4uriLui6zzfd1+Q777tdsrxkTcn6kosld/3z/K2lBjSZXtpSuqa0r/R6WWNZc9mRsrPlXuhvcvmm8t3ldwOpgUWBNYFzgfcqJlfMq9hfcXK8f/zU8VvHd1XaK7Mr90Mnp6pcVVVVHVU7J7AJoya0TGif0D/hVvWU6qbqQ9V9E3OhpfqJGyburRE1aTXLajpqztdcqxW1jbXNtcdqz9f5oLOpdVvr9t1v3O+8fwk0t/7+O/Up9W31m+pvPGB/YM4Dix9oe6D3gfMP3Jy0ZNK6SRcm3Xlw6oMLH+yCVvsmF0yumjztodyHJj0066GrD12dUveI/xH/lKNT1oIuPex4uOHhxQ+3P7y1wYbL0VDf4GooQjm9oRPXzobrjySifusjnY90Ko/D4XsF/MIk/jQ7wL7H29hB+IK17FnWxZ/mT/KlfDlv45/mK7BGH+Yr+VP8R7yb/1gkC4swhFXYxDARJYaLaBEj7CJWxIl4kSBGiESRJByiRSwVy8STYrn4tFghnhIrxWeMdlu0cVxcsP7N+p7179Z/WG9b/2m9Y/2X9a71fRuzcZvNNhyoJoHS2Cw2lz0Kr7gG3msfPFQfewc+xQl/UsPr+BT+GF/Cn+Ff4c/zN/gx/iY/zk/yn/FT/Oe8l/+C/5K/zc/xC/xdfpFf4r/nN0Sr+KxYJZ4WbeJzYrX4vFgjviB2W0qNmcZb1j7rr6xnrGetv7aes75j7bf+xnre+lvruzarLQo7h9YUFykskzXA685hC1kLa4WmOtkmtp3tgd6OYoc8Cx95ld2CL0zkqUCaBY9Xz6fyRj6HdwLZJX6D3+J3RQK80ipbNLOKj4uF0FOrWMsM8Qno67Piv3C3CHpbJZ7B3Sehv6fFf+NuMfTYJtbh7nHo83Pii7hrhl5Xi3bcPQH9fl48i7sl0PMa0YG7T4nPYIRfgpRfiNPit+IiJA4Tb4uz4nfiz8aLxh48C/EblBZxXlzHqyF+JS6Jvyhkl8UfxN+MvfKef4a3ip+LG7i3iU7xR/EPcdt4U7bmnxVX0cefVE/XZGk8i9Iu3hDHRK/xReObxsvGLuMV49vGj4yfKAk3xT/FHVXzgHw2vmpsMA7iLlWcEb8W58QF8a74vfireE/83eg01hsbja8bm4xvGFuN7cZOo8t43eg23jJOosVY8ab4iTgu3hFXxC3jS8aXja8YzxlfMzYbzxtbjG3GS8YO41vGbuM147vG94zvG4eMHxg/NN4weowTNoH20eItcUL0iX7jBeNV47BxxPixGvlPjaPGMeOnCuPPVLkOZZToESfFKaPD2Gd8x9gv+dZbNgssI5PPFR8Vc8THxFzxqJgn5osm8ZhYIDaKTeIb4nnxgnhRvCReFt8Sr4hXxR7xmjhgGWbJsXgs+ZYCS4ml1viI0WR9G3s/AyVixx/PprEFsC/07qtXZPHV++prr8qdUFqjr4gZviJfUe2Z2jOKZ6mdLS/Ga49SNAEeE7WTarGWfDbw95hcXlvEePF1Joqv125UXEP3WnyWWYrPFp+tXa241pCPGNcNLXxJzn8kjLVViizFW+UVxFiby4zidn1pyTUH5QU5KwjjMImxZlvNNvDmaQJXrjhe047nBmBsQCm5w3WvNb2QUyYv6sHEWFzEMKvGfoVxGCK7XERL07FSVyHukT1uUGSZiBAKEgllzWpmVF+tvgo/3aF4YsLyqungNzNL9ZnqMzUrNfaJd+QFfhNhj5F1J16aeInx6t3gTzW5fOIp8DYwUb2hJqC4dpKVgj7bqttqXFTXxO5ADWA/RBqOgH7iGUWWsrSK7IrsIPqJR5lRFlWRKC+Nvupg5XPg72WW0puBu4G7hL5aXowHLhP6OIU+d2IueL2awI1XkhIZL93HROBQ4JBZV8qaiT43B3YEdhA3tINo9N8Geg5f8rx4zVIQ2VLK4xRZyuPkFRxF2W2M4ra+NN7qDnnhnUuEd4TEW72iegV4pzSBmyj7rIbVlHUxUdaFUnKTqNft0NZ2eSmuw8TLy9be/ZXCZ0Wk7UIONZnNVj2tVCSqV1a3BbFVLwSahdXN1c1kHTcn3AR3NuFKke0mnAenDjTZ5MmWBeipoNqveCND2nJOgZ2KsJnOZgE2BQiWYKdDb5WXFInKS5WXgigqTzNL5Wl5KQ6vhS1XYk3KCM2sgzmv3Fu5t3YNIZ0yYQq4WwjpfQopVk3lOk3gjaKWy9HTcpSSNzqkp8pZ2Ikj6Cl/ryKRv7fyQFB6/hZmyd9Sub1yO9nhiaoT6GE9SR8j21Vh7edjBitXmTzZsgk9NVUuUjxnSE/pF+BzOsN8ThYyoMlKTxKDV5HI91adNjFgPPmjqrqrtE54FWY+Hz3lR1XtJVRlVdBAVVAn6aoWVqP3Al7XmTy86z3JhPdkldZJRhiqg0D15UGopiAiaFH2fUCRKD9QbmqmHHZYvl1eGkNFSvkNcNej1vry9ZpXuQXzxMtXEa5MZQfAU75IE3hZ1NsMtJuBUvLGheaqfDyruQcmlyJR7hofZWJKAKaEivcq3tPyA6vL52Bd3MUqultxkTBFV2I9V5wiTDmyr/HvoVYfuIdMnlxpsMSy7oqdipcb0pVrhfTI4tcDLL0BuepyZKToraJZkSh7pqI5iKwCFla2vGJ2xWyNovxy2VFwsWbKmlAq7zD+RPnpMthgRRm401CqmuNnjZ8FXjrhdSu82P3KssG1mzy8G7iFdokoJc8TwpvRo3aQjffCGzisSAQOoyS8gd3MEtgtL8IbKIOnCWxCrU0oNd608qwyWXctuGtRajvYVbELvCWEN19pBOs6MFsTeAUkYzLaTQ5o71IYmvOAly+5J9ZERSKQWLHfxIrXAKvYVqF3P1HWXroQtnANqK9VdGqsFUvKVpQ2gnsW3LMVrWQfcifhFQsIa7GScAW15CxMN3nSsjaj3eaKasXzhUUQqUq3m++Ft3yeIlFYhTJopdOYpdBdPg2vCkXpOT88SHk1aqWiVHgDR0p7/Fjn5W5wDZQa79QA9uNyB+H1K7zjGS84C26IJ20X8WvBMZSSVxpmu5cU3q/fC2/ZPkUi0BhoNPexrcBTJy/C6/XL3aYDtYoCRYQ3oTS1BDtIGfaZQFogjaxmSznWf8BGeMuVRuT6v6EJvADJqELt/vJ+qmfizTyo8G65J16hSJRvLN8YxFt6HV5grbw0Cn9ryUxw+1FrWfkyjbd8rn9hCWLQ0uPgzi2fS5ZzrewakE0hvOOVBKnbMk3gVZKMdul5yl1Uz8Sbe1bhfeFeeEunKxLj96MM4q3BWtpWWoNXhaLkhA8+pxT77PhOlApv2d6Sgz5EQKWjwG1FqfFWl8EiSw3CO0HhdcM/QIr/usnDu/5zaFeNUvKqQ3j9ZxTerffC621VJPzb/GZs6V3ELP5OeRHetGL4HO9M1FrlX0V4WUlU8UVw68Fd5F9EltNRiujH30h4a5RGEJ34azSBV0sybGjn9XupXmifyla+99174fWcUCQ8J3wiiNfTxSyeruLryA0UCt/iYvgcz07U2lncr/GWTvPNLEZM43kO3OeKj5Pl9PthkcX7Ce/9UoL/OGph70JGEORJGdi/PDOQEUhefVgMKTPI36oIUiBzej5S3OE/r0iUVKMkzP6TzFLi9Z/Eq0bSCK1x/yFCMkm1g15KkAP5d5o82RIj8N1AKXkPhmmuWc30SxERzFEk/HN8h0wEDZjlBt8u3y6a5d4SRNO+jYTgIdmuBDuHH/uQb43Jky3hn/2JviWKNyWEYCx8krGTYowoxJO5WDkN2M9lhLhR9denSJT0oSQcJUehiaPyUhxeDI9SAg9Vsg+l4hQgByzZCs5WlIqTvQkc+KeSjhLKfkocJdi/SloJfYOSJntfqAm8R0heI2o3opS8qaFdqSTAWyPprsSlSJS4vE0mZsQhJQne6d7pZHEbfNgBvTUkfZps50M26sNe4/WaPJkBY/S+Pm+q4v2fsD08Drp7mXQ3CIFvqyLhueDbGkTg64DNn/J1+Gj8PocP4/cFx/9h1U7aLfZq30KTJ1ti/J4NPj3+xjD7aVf2sy0SAs9cRcLn9DnNVTcV2b1dXhpB8fri9Zi924RghppLRMzFlzSB93+ppQO1e4t7qV4IQbRa+8cjIXD3KxLu/uLNQQTuE8ziPlG8rngdIUgoTgjL0j8i2xUh93Uj8ytuMnmyJaJY9/riaYo3K8yCn1EI3oyIYLYi4Z7tnm0imAIEU+SlERR1FMH/uQOEQLUrgv9zZ2kC76PUMgE9JaCUvDkhK8y7yZIjSc/rVySKOos6g9LzMP6iVfIi6QlF6K9oMUmfK9sVYvxFMzWB9yi1xPiL6ovqqV4oejitxn8iEoKiOEWiyFHkCCJA75YiIS+NoLCjEOMvvE4I5isEGH/hOU3gNVFLxN6FPYU9VC80A/XKCo9FQlDYrkgUri80YwH0bilsK1xbSLFAob0QMXPhMkKwQPkP7F6FmOXCuSZPtqxB7UmFDcQbcCpgvGGL1qcC+qxLobHgnXQVf4mCHQWwqcI4krJQSYH1e2HnBbdNHlORm/D2Flwi3uCzh9fo7OFFKSdyxliwQZFw3nbeDo66ABm387K8TA5yJmefs6+AbKHAKDAYdwZP1RbJnvIRMTj3agLvk9QygL43OzdTvVC+v1HNxHcizUSBUCScCwrM0xD0bnE25t/Jv6MR5K/OhwfMv0IIHlcIkDk5C/DaZ/JkS2SezlH53cQbOBPfDZ8Jo2nwTOSn5aehhzUk5QklBesoHXFN/hKTJ6VMg4dZmD+beINn4nskZdiQmTAz0ny7IuFZ7lkeHLX3Nvxwk7z0qPOu5yJC8V5Greke2h28K7wr4PWqCeOnVNwFf+RxawKvhXrbjXYpnhSqF5qLJuwOr98re/cuUwTf6G0zcc2TvtHb7KXzn7yZuYh+vNCBu8tLOarnvAeRiXcy4VoWjK/c0pL9Jk/2Bo/tXuVNJ95g3f2AdOe5t+48pxQJ93jPKXMHOQyMuZ7DHp2Vitz9OZ3gQgfuFA/lpZ4qTxV4wahkueoLuXoe4njPGpMne1uCUZ716Dn/dAjjmFxlx4cj7mvjFYmsZzyTTFS5zJK13OP3+DUCd5e7C1wXIXhK7QVY/VnYPTxxJk/6dGSkWVXu28QbrKXdtNZfM7U0eIfZrUhk3s40V7p7E7NkXpYXofG6EU9k9hGaz6h2iCYyuzWB10otsV9n7sncQ/VMNGnXYUuvRI403G5FInOF220iSAWCBe5UvGpL2pWHmMIdzPlWqd0JPioT0WreDZPH9H6V6c3TOd/TYQh0pPpqxH1upyKRtzM3MYgAvVvyNuQinCQEuXmwgJxrhOBzqh2inzzMfc5ZkydbYr/Om51zTPFWhxCMhj0b3ZF1kJetSORlu5aZCBxA4HDNc80jS92RCwtwTSME6vwzF6smF1bpqjJ5eFfmi7lnXfp06QthCBYBwY/+X7Fy7hZFIndL7pYgjtx2Zsltl5fJwf6XuzJ3ZXaLycHOk7swd2HmapODWCx3Ru6M0eQLci7nXAa3ntD/l5SWcxqcIk3gPUMt0yA/DaXk/XcoSsFwvjrYE+esz4EGcoLx3xdVr4j/XDfxesnk4V3Mh3Cdz+kl3uB18n3yJjn3Wic5axQJz7QcMxbKgZfxVOesyqH9L8fIwf6XE4yFnlVZA/Y/D9ZKzkyTJ1ti//MYOfXEG4ymh1bty/dC47yhSDhvoCQ0zvPYC8/LS6PJXp69HNyThOZLCs08cLo0gddJLXegpx1O/VnFl0Mad6672xdR+jJFInuay4xKnfD92dWuKS6KSsfdGocIyBWMSr8i241D7p4NXbiyTJ5sCV+ZbbgSiDdIF/yzpIuXxLfEgUhoXE2KhKtp3JUgGtd0ZnFNH3dm3BlCs2gcooxxxwjNVxUaZAEu+LVx+0yebJmKnlLHbVG8DWFodJ4gYwjk3JFnJeOsIpFxFiUhyehhloweeWkkWeezsP9lHCAkatVlYf/L2KYJvK9TS+SaGR0oJW9TaFYyWlhVJOlj7ygSY++MvROUPvYKs4y9Ii+SPi8LFjD2DEnfrKQjHx17VBN4z1PLvehp71gdtW0JSR/7HH8iknRax8J10nXS9AFOzMIheWnpmRczYQGuXSR9q2yXiT3atUETeN+k9XERPa12raZ6oVxhlZqFv0dcoXsUiZw9KIMrFCPM2SwvQjAvE+PPWUcIXlQIMP6c5ZrA204t56GneTn6U9aXQuPPmYScNoL0zCpFIqkHJUnPdDNL0oFMdyadtLouujD+zFSS/rKyXow/CRFIpmHypBViv0xqdenTtp0DrVD8k05+DlBkOggJ9mJJAtQaRKJi8UXq0khmuWQGOpOQ7FJI5DdJ6okYe4VaYk5B2kPvDumBOcI+f+LMZmB/Vt80k4gMFod3C/RZnMr1NAXRICIE6ZNqnnESnBpCsodqFBAx9u0BMovDZfLXpEzjIxFk0jjSa0yZfkTiRelFJBOjT08nma9RjUTw4oiDfi1hJ9xS7+p7FNA7Is7SoRIzFpkUXPmzsH5noVQS07H7ZQTPgL9DNQKacL8/bH07efhqTxC/Giot/Y4mVh+Uln4VKP3MT9KQ/yIW1tIOUI3jeoyKI/U2c7B3M46r8ZXgnaES12lyXjMlrsSu0e/sJ4lRYXvNQaoBCc5DxBmoy7dMXZZEkOUkyjJlxWH2HOn6DICPRd6YHjyf7iJ/dRV0gzgDZZ0gWfmRZI3dpynVjH7HbmMi9UrqFZIFy089S7IOUY028HqIY8qy90HWT8LyJRfzsTo2XZ0+8DFVJpGcMV7kCV6USo5c62PSFAXfR9Y3xu46r993wguk3SEch3WNtCuacP/DkMWknWIPhD11Wz4+dNRpezQ5zU/E0xD1Ofc56fTTiRzFuY2k/YhqwK84O4kzeF+8ojzSi5b8yKNPq9bkMuPrtAJ4IVy0HjFzaU71GnwfM55xIU1n+nwMvEtGL+H5sa4xGjOecYQ4oRj3isLzx6Fjjss2iWTEpTARl4JSy4D/iwtmGG/oGrE3NeH+WEinsWeZO+zpBN9h+uF0eMoajBr9xR7QJFYG5cUizhKLhPYQfATsNBa7niAPkQYJIugheqgFIi0RIM5Aq26nXWB32C4QLj2gyZJgSkecZVG3SjpmPxaxmLhO0ifj/jxJP65b2N8D7yRxBkp/lqTvIekDNG0/pGmUaV12ZJij9o0i6xp9Du8FresE1YBvGdVJnIGy1gd9RURZ0zSNvmXKqoEVXB59mWQhPxsdjHdOUg1Y2uhjxBko6ytBXxFZqzEXNDlOBKXF9DLhOOQwP+GI6cbz7hj6VsUo2LVjM0k/RTUQzzjWEceUPhy2aHwxLDuUUidhh0Yv8Z2aYhYHpcS3MREzO8aMvuOX4LmBJajeuNitZCOeiSkj2b1UD7Mck0WcwWv4pJrRVyKPPH6Vpmjz9C8eGXX0megz5vMcPPcgWlMjvw/Rf/RBkn6aasD/Re8gzmDpp5T0VyPNcXA3TzSCsuRuPuLmiJskqx32fJFk9YV28xG9xJE62TNQovg5WfBLeCd8vHWsUfaZnGoSyUxGy+SoZP29EJHSmozdzXFLkUZhw33wO1hndBvHaU24fzvkMRxdbGLY027LkkgIHBs0jTSjOMdaJkYuHqmtQCTfdmBkDszySG0HPBU56sigB/k1tZkOXoA4g3V+Tmlgk8UzwGvXQ746w3Y4NKWan344DOyN7anthGCFoxHRK/xjqokx6QJqLErR2Q4fCftPnUWI3qEa8Nmpk4ljIrLsUIjeiaSJpHZNqeZ3cpIQ3468NVJrXjiuJ8FnJC2GPFr1IxH/jAyeV/2G2kDmyKPEMeVGrVdy+4daXfQuTSPNk5DoTZDaMbKDZKSAgt9C+i3VWAHeYuIMjq6eU55l2KA9sh5rXJ2UJ7ebFLQ4jDK5NZm+V+KITrwE3mJFkmNJuZ50KxHWlTxLkUKVgtgkeRKhepf68WvC/cWQ3SWP4k+EPdnFbyLjctzUlLLBtAJkZylrU+jTj6SWxKnaylOWE66ZSXMTsdYd3eDpM2qejPg3JXh2dYn6QRyXUk0cU1tilNLW85HRwLsrciww/T0yFMcMxwyNJvHiCNiXPR019OmqJfl4Yq/c7eyI7R0UH0uNOdIJzWXyy0DoiCPO4JVyQa2U54esFEIVs8uk4D4AW4nZFLOJUE0dgYghZp0ijcqfWDUC/iVmhSKFygHrjAl+Z/YK9TNdE+7/GJqtmAC7P+zJbXl8qP06+jUlzDDn7SQTCZMSJpG0GXgvuD/8iWogw0vIIs7AnfFF8pebyH4H7Q+OJZoSzezfMRfjPpxofvvLgawvcY9DZyw86QzqBr9b+GeqgYwvsZ04A6VvN/OFfPNbGlnYBaSvatIn9EnXTAp6iX5YZ38SZSgy3ko6qUg9x0mfcViRerbJ9/co0gjLQEGEf6EeyRPh/kZI/0kt/KmwpybyYgNmI2maJvt6Ex3iFPtquz4x5YmI7+wtJO0m1UCcYp9LHFMffCb08U2KFAbGQgWaEs3vwiLSEYl9iX0kowkUPAN7j+wLWWTifuIMtvqfqhl/jfKmwbHQEU3C/FZFzF7UPiaOaWnigI51xAHSP9a42EHSb1ELRBTiOeIMlt6jpUeKCGLqNSWa38eJkRHBjRE3SBb8/4gLJOs21ZARwSniDJb1ExppfoR94IxJwX2gR0Y60bTHjYgLi3TuUI0dZqTzr5BlRLeHf7M6epUlwslF9CJNI8w8MHoWRmYfob/xwBOg0YRgHvg+1cD+nnCFOKEdtVWN7K2hMhIOEplrM2EnPMOeBLL8BPjuBLJ8zqnGWlA7cQbvbEfV2iyIlF8nNGiKM08q0LuI88eRJ47HjMTRSQW3UI1R4CUSZ6Af2Ete6EU6gR0gK/68ptCpCHoPOxWJl9/HCMqyUo09jE5FuPwNBzeahoxunx5dJDtEDKwo2sxbVRR8IfoC+Rh4iWjKW/mwsCj4CHEGjm6P6WMjjU5oEqOCstC7ENEimmRhhjh9EsLpFyBx0C6/TJyBsg6QRx0WdpYdFnPFPafJfteUtgb+6ppde1cR0xqN+DcO+amd/CtyZ24/QfJjqI30eF3EGSi/y/ToEcaKnFyTy5Rug9UkxunzAx67CRz6LTCP1TViEdvEXifOQFk/NE+AIsiK3aXJZmaQ6F3YLtsoloyFR7VRBsnjqQZ2bdsx4gyUtYvmMPi7jvCdapH+ZUcwN48NmBKRm8fmxuaaz6l4To0J5e7oPTYqytSG/Rbm4lYw37MMU94f828nn8dHUL1TmnCbGPI89gN8fdjTTuQBQ/eS5zQNM8/S7Zj/YVuG6WiY2xG7DOsgaQ6qMQ+8VuIM1MpBmoGcSDNgz9UUf9OUhfHHX4zX367nMYhK4k+TLPrFSAx2q/hu4gyU9SbNwMuRZFkOagr5CMvOcB8RUxPmI1KpxlrTR8jv0HHxypD9409M55KvRJA4SVOYxLJwidEnwyTSr0wsDlPiKCXx1SESr5HEV4dKFKc12czzAXEUbRpsDSRxNt6rIolpVGMbeG7iDMyU/xz0SuKlCLIWaooyowCB+CTqWBRFAcOxIqPo0y7upBqIrKK2E2fwuP6qx0WR9gBZ/I6mkCb5gFPv4WvCNJlONcxTb3CkJp8fNLrrNLrnI42OrzMpKHElIrCVfCVJRM98EUl0UY2ZmnCbGVplvJo9EvZUZHksgrQ0TVbznIPbYc83DTrnkDoz6JyDj9M1kCdwo5c4g3V5lWzkWxHOVPZqsponV2wrE9bd1t0kC/7JSidXnH67whCtWdcRZ6AW/0JafCGSFoPnN1HppixEa1EJUdq/8WGIxGVqr3rOY+b5zbBrxJHz9tKQ0d2k0R3433/mNEx++lVDEj1s0GdO3BuaKebgHWFPNhUpcktthHV+TpPVPBu0nIBGD5GGuQ3xr9KulEC/VrFg37FuIs7g8Z1h+rPmCCvBskRTmE+ZG74SbGGf//AiqlFtroQipdHXhkjs1RLxztB1ftek4Dq/Jn/HLK6RRPmb736S6KMaJzQx+bVoU4diH6sMe9puaYkgrVOTxfzmr2jD7hFnoc8DpM4UEtl3KdWYA7pKnNBpwmw1sgifoalzZpDVjILZIczXHitFwVZ4KWswCi6nGpBrbSfO4Djxa7TDRcgh/p09qk/egvZYMcQeQ78FkfbYPMAe31X2mBMpQ+NnNDHzVzccmQtshnJwhv2dH1SrUaOoD7OaKmqxwbSaKmU1mwaOW/zO3B1eiHR2zRs1CfM3frwetXeoTFBiSADHj/c3qF45fJW07y414xpJtekLuWgmzmDL/b32PpHWijrp7g1fK6w7fK1YpoaNusb0hcFR1yhUGweN+qL564sX/vezrc5dg7NdN2S2w052EDs+GPZks3xSofn/kbkwTOYDQ2ROGiCzfoDMJ5TMb0T+ZM8W0MTM3ynYEMvC4kybs6VKm7Ol0nz7ta8Iap+fCtP+ZN3CesnU/mQl+8VB2v9bMAsULw/VhHWHptB8WzeEzzefEyZxCtVYZkqcotaThw22sPeYjikjWJjVr4mb392zZiFKaOJ09smuqjWgJTZQDWRymHvNGSzrFsmK4EmMHpNIliF/ZXvQOEiy2sDZSbKmUo0NmnD7odDMGq1sethTs2X+AGnq10DqO+qaglY1AyhnsBkkTeqMTpu5/GUJl/+QMci2wqTAtsItzWZpVPMb2sH9wH9U9SwjYBn7pqs+VD1LgSpLVJkfihNYaqgOewf4ZN9dTH7KdBqv8n+XXud2ZIWHeTwykyN8Nd/HjvEf8R+zv4sUUa5OiLgh4/A1JFn3lqIwjGYZbBwrZ6+jt1+yX7PfsBuR/sNC+RLtx/Ur4/8RNrN2ZuFL+UpDnqlZ2Dv8MUtJuCZYskTPQ1FhOq0wWSMbpPYATr9mAUbB0vTvh1WsKdgdleEb1netF62XrL8Hh1v7rHQOYdmviJl9KL1Z6DNYeaLIDK0zpZsupZs/Kt1cCxtDLhvB/sWj6R9pbt3zP2lGSDT0PzFv3+OfYuQ4pb2nhWU86uSZzzLxBTP8/5T/SWb9mw33kGBjsbbhkBP+rwppLEb+K4/6T54u/iRfrv6J5yn1nyMx6v9x5L/j7GN9fKT6T5wl1rfDWsdh9GvZs/Kfe6QO5b/oyH/NYYY5P06F1aHe/S7u5Z5hYL0LpXXB7md3zRHpLEewajU/aq/ijxJviupD/X6Nz1O2/80wKZLilB3Eq/6T4AUivq9WriHXIt4Pt6JpqvUbYWMrYsn0T0Qf4H+I0CaZ/ifoA/xLUJjkU2H/0CH317ywp/3Ktk2M7/9BjfvlMN56NtbUnsv0K3U0+4+r+p0m3038ZmnjokV8Rj+b/b+n+K3iC2q/0r1mqdZe1YNuvUTNG8eqDvabZr4j239ULFDPgs0dkKXCVvjTvE2SmgO5476OGqFZctCrYXwCa96pYgfOPhLWRxaL/zdrCOsR6+e3CKfetb7L7FgxVlh9FNZNXPhY78r/yuDGWwNsIFrp66P/AwwX9+UAAAB4nGNgYdnAOIGBlYGB1ZjlLAMDwywIzXSWwYipBkhzs3EyASkGloUMTP8ZGH78ZmBhAINgRy9HBgcGTu3TbAr/FBhnsu9kfJDAwDj//nUGBhYV1h6gEgUGVgA6XBKoAAB4nG1XBXQVyRK91VUVCE4CwcPkQRIguLsFd3dd3N0tuLt7cHd3WNx18QSS4O5O8jvAcnb3/J5T1dX9ZubM7ddz7x0ABgDbSGQz/eglroftvyAIbugLd2RBPgykQTSRptB8WkQb6SE9pSiTwuQweUxd09XsNcfNSRPCwnHYg1NwGk7HPXggj+FxPIkX8SreyCf5PF+T5JJG8kugNJapMlPmyhLZIjtkjxyU83JDIuSxvIxXxHu49wLvz05ix9txOX5OOierk8PJ7xR0CjslnM5OH2eQM9pZ5Cx11jubnW3Obme/j/p4+iTxcfn4+WT2aeQz3Wely7jcXPFdHq7EruSu1K70rgBXGVdTV4s0CdL4pNngO813oW+UXzK/on7F/Zr4NfNr6dfW39O/lX+HdFEBWQJOBJyOirJr4A4HWZEfwb+wB9MGekBP6ItJarL/wr7HHLPYrzPY7Rd2P+5usQ+z2CfwZF7Cq3kTn7LYISkkrRSQEjJJZsgcWSzrZbvs/oH9uoTLI3lhsQdZ7MGOp5PEcX5hz+7k+429u8Ue5AQ7S5zlziZnq7PT2fsDu9cv7PV9Jv3GntBiT+by/oW9iau5xe5Y7PCd7hv8D+wtfmFvnw4BHgFHA05FRbnZXWEy2RVA5GfqE3kI/2qRlyNnRa6228af4/ycMRfMCXPIHDANo4Ls78ttDI8cZvPI6Ar43tvGHPynffv2Pcvf9bvDQNhjIDw4ehTeM/xGhMe9rOGjwlvbo0K4V7hXmAl79O/rI+pH1LC5ULhnRMGwfPb6RWGFwnKGZbTVj+cKixcW9+6T6OquF3CnOxByHAjNHZogNH7Im5BXIS9DW4YE3n51K/D3LaPfgE+2S0Tzfk5wDa7FdbgeN+CW3P7XXOsfuSV35t7/fJ7oEQ/5UdnM42xMs3HMxivxk4ySWbJKdikohaPPie6lqBS3VXSUs/FFY/53jf5u8k4+yCeNqbE0jiaInvmZf1SxfldxokPj/T3/c/wz3LL/v/u63Y550z2Re3L7H0aZ+eawWcYxuJjUNUfMKrPaLGF/M9tsMrPMCjPHzOXMHMCZzEKpY1cqOVLAB77Ig7wojGKohCqohjqoiyaWN/pjAAZjNCZgERZjBVZik1lnVpr1nMts1yfYgyv4C7dwB2/wFp/xjdwpDsWnxORF3pSX8lMBKkKlqQI1pibUglpSJ7NGmpu1nINhFliuSWHfuNTSQurrI2lAg8wBzmk2S0N9I005mxllRutTLiz1zCJ9a0ZSkDloppjJZqoJRkLLeu5IgvhIjKTwRnb4Ib3lubIIREmUgguN0Q5N0Qy90YbToyemYSImYwpWoR+VxGnsxWFcxEmcxyVcxzPcRQQeEyOSQITblIrSU2ryodzkzxkoJ1WjilSZqlArykdt4Imzlm33Wa49h5S4itS4YZnmJlLhGtIgBGkRipx4AX+EWf55glx4iXQIRwF8sFz8DoXsHi2IjyiKryhimboixUR5ckMJRKECxUBpfEdxUlSm2KhKcSkeqlMC1CQP1KCEqEWeqE2JUI+SoAElR31KRknRkFKgO2XHH+SgG2VDH8pjWb8ggqgwBlEhDKGiGE6BGEbFMZSKYRyVw1gqizFUxvJjI8yn+phElbCQGmIe1cMCaoCl9AdWU2uswWbqjK3UFVuoC5VCBwrADKphmfU9elAOeOECkuEyelEujKASGE/lsYE66BW9rC/1sb7Sd/pan+l1vaG39I7e1RC9plc1TEP1pt52U7cYJrP5brKYrCabVaWcprrJZXJbfq5n6puqppapZmqa2qaGqWPy0BgaS5tpBK2mVbSW1tF6WkErLbNPoUk0j5bQEBpKw2g4jaLRNI7G0wTL/pMt+y+w/L/Q6t9iWkbLaSmtsUq4iY7QUTpGx+kUnaZzdJ4u0EW6THfoLoVTGEXQPauWj6xqPKc39JbO0Fl6RyfomVXQF/SSXtFjqyev6QpdolC6TyPpJG2h97SVPtA2+kjb6RPtoM+0k77QLvpKu+kb7aHvtI+iaL8BHTBEB43BcmqOJdQUy6gZEuAUPHAGsXAEcXAMcXEc8XACsXEUgv1W1Q8iBg4hJv6E4gCy4Sly4Dly4xUy4B4y4gEy4SEy4xECcB/lSFCGDNpSOrSnDGhOLrSktGhFvmhNfmhBadCRMqIzZUYXyoKulBWdKBOmUlVMp+qYSTUxm2pjDtXBXKqLWVQL66gd1lJbrKf22EgdzQ7rIfaZnWa/2W0VdZe0lNZmMcditY4iISfixJyUvTk5x2R3js+p2IvjcjxmTsnJrOp6chJOIG2kEZfiQC7BJbk0l+GC1oU4XIhzc1HOyC7OylnYl9NKUn4jvhwl3vxJUvNnScHvJSV/kCT8gO/ya/HiexxqGTutFJF8HGkdSyHJw98knZSXvBwmZfihZW4j/lJOcvMdKc33LZeTJBaRDBzBIZJJYvBLcYlKgNX7XJb3Y/JXqwBuVgPKSk4Ol1ISy2oBS3p+ZP1QFnG37sCDn4knP+dLfJWf8m2+yE/4Fl+Q4pKD/5Jikp2vSCUpyTekopTg6/yYb/J5qyDZ+LJUkEDrMOJIbIkr8SShJJD4kkwcSSWJ+C1/4Y/8wnovH37H37kal+PyXIErciWuzFW4qlW3ulbjalulq2n1rj634tbchqvzDJ7Js3g2z+V5PJ8X8EIOtm5uMU/laTyFp1tvN9k6u618gA9bj7OND/IR3sP7eDNv50N8lLfwDv6Tj/Fe3s+jeLT1Q/14IrfjvtyH+3Nb7sAduZNV0W7WMXXhrtY1DeIgHmy903AewSN5CA/lE9Y5nuLjPMA6qaW8jJfzCt7Ju3g3t+eV1lmu5jXWa/bkXtybz/FpPstreR2v5w18Ri7KJa0ml3WKemp1uaKbNYd2k3c6VRNpDflL/9RAHaqiSzStNpf7ukVzand5r9M0sdaUq3pKy+tYq6drNKO2l+e6Rwtqf/mu8zSVNpRQPawldJiqLlVfbSEPdKvm0h7yQaerl9aSa3pOK+tETaAbNKt2ltd6QItqkJIGq482lXA9rmV0lLrrSk2vbeSJ7tR82se6gNmaXOvJLT2tFXScxtW1mkk7yAvdq4V0gETqfPXWRnJHj2hJHa5uukz9tKU81G2aW3vKR52hSbS2XNcLWlUnq4du0uzaVd7qIS2uQ5R1sabRZnJPT2o5HaOxdbUGaDt5pru1gPaTbzpXU2oDCdGzWkknaHxdr1m0k7zS/VpEByl0oTraRML0mJbWkdaTrNB02loe6w7Nq73ls87SZFpXbup5raKTNKFu1GzaRd7oQS2mg9XoInXpHxKhJ7SsjrYuZZVm0LbyVHdpfu0rX3WOptD6clvPaEUdr/F0nWbWjvJS92lhHShRukBTa2O5q0e1lI7QGLpc/bWVPNLtmkd7WZc0U5NqHfs90V8GyQAJst8hY60bH89zpKMMlT4yWnrICBks7aSfdJBOMky6ynDpKb1kpLSXIdJbRkl36SxdpJsMlL7/A5avJe8AAHicNY49agIBEIU/2XULa8tUYpU6p0jtCbyDjeQEEuyEkCI/JKIoYqIrKuqaXSVs/hSM2UqClZXkACG4eVkJw8C8mXnfTHxFMn66TzNNEsLtf+6Owq+//l4zw8dRLGkqfBI44TdFVXOu1G2FP5rmeKAvVSCgxzlv0lM6VFlJ3zKKndCWcnlho5nPO3d05cyLVeaeAY8iBmLa0Xwp5zUNKYeJ+HXt9PF4lXOtOzbP+i3gU5weY0pcyPcUMaq67KpeiHFDTbtDpvrgkooo3eiLDzZGyjywPPPMOLSOrayV+QWU4mJ+AHicjVfdb9zGEV9S932n4GwErgGq6BJbEgEo562FrBoJodOd9dHaJ93ZIWW7IY8n2UqT2Elby2miVnXr2ti+t+5/sbRfpDzFD/lj8leov9nlnT7gBiWW5M7HzszOzszuhmv/efnvfz3/x7O//+3pXw/+8uf9b77+01dP9h7/8Q+///KLRw8//+zT332y++D+zvY4G6XJx7+9d/fOVhx9dPvWcLDRv3njN79eX1tdud5772ftRn3eypuNjuhsN67Ms7zRRLd5Zd5SlY6qaqS6GXAVbkTu+mbUXXZcN3aEq0JV8rr0pmOZTQgxRGAUxkLE+kCsb2xFvCsTTQRmeAYy9IUpregpuzOMVC8AdAq+ruEpuHKOvDohC65YX8pxzmY84EMnt3Sn3PlnjJnEQo0C4YpoG7x5jbXcYdJBrzXpWfw6JPLDNhvhzT4Sh1bR24oUT3biFXAz21O6DQ7ZL8QT008UzzhXFU+M+pF0lZUIp4A3I3jMSh3pCpfH8eHxmzniFi5k2WwpF9aLjTy0Xgy2oqM2Y/zFMHplW3YnWYrzn4MWHXHGQo21CUtIAjgBbN3Cyryya5rfOQoZO9DUkkZoOMMsNK42wVksO7QNrm0U+VpRyGxQSoYSTrhLwNUM7sBwv1dw10BpE+VbZluMaaJ54CWsTNgoh7WwHrbsWRtrQahXwHwL3rrFXresWcvJIXNTow+tg7weOkda0mbBeQBOwh1McbCc2E4Jgj4z8VsnM7i1Fb1uMcjXX3As0XNlvpvbNwJxEtYbEVavm1s3ggShTeCM1+UIaxUOIuJNHMQ8onv5yjxFF4/EtiPi/N135aNu3m531mUHgYxY0wGWpxU/CaQJOQo00V5EmM54q5noJWARSBu0VaCy2zxRoyRAl7d7skdRkRI3u5TbM15ulTzrA/YB/FZpqYbYXlJNsTSlfMg+NJQKUapiSVmXjNe7ossv78pMjBCBYT+67+zEKWSrUKSqJJacvMSWkC+XLUypm7MbAea2jhi8GfTvIEnJGVzKZZ6HJT/NUoKXXeS9LEhieTk+NaLLpQrTLAFHN9bMyEQguyLlY3gZ04XnBgLdrS0aM9yKZGssxgIeDkOZYtoOz2JHxpn2OMbDNHZlvnxSnYriZFPOe9kOPoecjRIxMgjKzvO4++cRO+A6jRNrpE7/Lf2Xa6I7Bge96VjNIOJcPo5NyLC+rhv/k8k6xcSxplq4bP9qAlkFBABNqvtnwQdTsEdvAq+9b2JFlXyKvMhVnzjq0ziYsqTqYMQlb4tFQR89+Dq9iSqjc5ClVJwqFHtArAHBoxFiGQJ7iZxEHIaV/Kkm9XlwRiRKqjWEatuj6aiDPk9iniTAIntch6sy/nwnpeCists38+mj9uOXygHGMkogR1WxA+yk28JFtVaUtMb7ZGMJ1rFBpJgjpZDKgoleD8wQ76uKv0o/tEeBSLexiKSPp9t6bA/mau+QNKcr3Bgstqd9CcehWozok0lEo7qHbCt7F+RFya9KVK17KLglP7udYFvgbd7jeqlTRDI5YZWgGIIMY90jRozXzVefBfm9qneC0e1hYJhrWios24xUf8JS1Q2dLwJl/2QBRJq8tYn6UdILRc4re6twb4iocmg0V/YwKpZHj1+loc5kwcwwYHTZpW3RndjbNPYapRXdWrrVPVXzsNCqBBsMuUrTOQkC9GG0GTOjzTUTQB+qeEHRE0kKoORt6zmZ7ZBT+cRBIRX0OofH3/VRIxNBbxyT+ppWRCO0aGkEk7sqRHybKwpNpjWpreopnEY3dKtqm4lmplQ+6/jCe0fH3zHjObd4KGZols+LrCzybttRD+JgbEZVigrOUVFRubMNfdq4g2wQbhV1DNNHVnE1CLCJ6Lk9N15dM9WBotLqCdZDDBUddokpJlYs+jCkllhRNsBpT7yymVUTC/Sri4Xctqqo9lSM2rMtFHqZJWOzUcPLbMG5Rkejil7oul7bx1SahlHZKcU6ZHy1FxRRbL6Pgyl9j3KyOvFkjWhySixrcXsmNvzi+ziovXWUrP1/ymrFaqq6plE18ms/rmrGLNCaWa4120heM3UCWD+Tkkpbfu8dytCWfwH4izDtKoy8WlgJ33wDU/qkuqYxGkS6Vckcs2xeE4Q2eN+Y0G6C2IY1bxzDhXZ0fMweBxNu4wTY3fBMnBfkYrSJzr0gRq9HbwKWHr1FJjWLLG2dq/qFeLOm9bNEMRVGG72YSiQot1o4A5ecMjT6vA13LWp/+jAVsFzMrapfMJSJwfYWpWxO6j+V/yMcQJk+XLJYnkeofawH1nr27ZTaeeysRherPDv9E7JIh0ZHNTt0fqG9qU4B8D7Wd//7oubo48Qpx2gUpeJp7GXyfXVSEh4Gk7ETv+3olC7GnsMOo31gyVPf006iLPzLvkuvQ67T2ijGHwbFQXefVvepFvc04HwX56yOhdMWNspd2qo4cdd8XeQkDjy7aarrkL7GXMZZapNOx7gBiDa3rrFr5jIkinsG9oCSF11zrsa4Vxwe/zAXm1JlY5PHO5Scty+AJPlFXDTUM+3egiY0Drt4xS+4aAbPkJyGj6xv2XJ9ACfQjayx4DTolje5YL0MfozMaTyqlPpYPHHJFeq2+AqHhY5QnN9FSQTy+lwsJbZTKegmdTsyXyJZ83N0MqBTTMHrzOGOdgK25ijc0sPj13N0XZpq+3qi7Utoo46cqFPZW7VRlFl3TKyhafPzXzJh9Jf8Qqm8K7dwP3TVT0lxYQfAd+ZiLQGWvCRL/gvbMGjtAAAAAAEAAwAJAAoAMgAP//8ACnicrH0JeBRVEnC/7p6e+75yJ5MbwhEyCUm4MiD3GRUh3Mgikl7A7HAICIjcQkRAVETQCCxmEVnUqIjsiK66WXRZxIioQfBCXVkXFQFJ5uV/R3dPz2Si/t//O06SYarfq1evql5VvXr1GJZZyTB8oaaW4Rgt4w6YgFYEbJDhRUYXZArQf4U9/HafPcdn963kDoezWV34uqb2xoIQb2MYlumKnl6NntYyRiY9YNMBXtCLgsCgNnjSQlGBvbx7gd1RjtoBPpDF+TiA3l3BTpAJdp6eAnVTQOVxsO04bhRMhPv5C+EytpFpa6Nta3PZXAYwDBA01xmGMb7EmgAAdeOYguIIzEAFpjUC80gUjG42hWFyMQzQ4tbAADRiC5dkBaDzuMgz0lNwcqRl9NSXSvsJAROXQIBZBw/AK22zGfpYh31d+62+yFPPRz8lMOQpbwOX5AHMkbZrL3fw3L6Y3iBjiPTGpMR/Sluo0OwGpZkthq6azro0peUblGZgGnMdY+Q0Y4yuIIyUp9RUK4yh2g2JaikEuCOqxfZ27bd7Q8/tUVH7BqUbeQ6P32lnmJK4T63WHYjpDVNtKH3KDEDP+E9pyxSq/YyeNb/MRdgxMn5NrQKFxs9YGqJGHIezr3XI2TUyDOYGGWZuFIzwjdJOW2w7WEJhFZFQL5PMdAp4E4DLkyh6sIDqLaJLX825XFRQ7X4k7fZylaxmCm6Xv6hUK2Rl5pYU9yyNll1OXLQgq7ujW5f5y6vGRMtxVWWV8YD+jkkTlngiIq2MaY6Cb1hFw4ERGpL58TB5ROIvcwLjJlRkGA/DvNJ2OJqKM5TWoEEZ/TZ59J0RzEg0eivjZAoCiRa7qNGJFo1Fw9gAjzWdSS+aJEVVUFDuKC/v3p3oPOBzI5VH3yU+LeD89s5gC7sNHgc8bAUBaIIfDALTvmvV1DbAYQ1wSMPVq/yF1le5QQgz0iuZ3wSqufIJZq7IvHBMHYKZRzBLYHxMVsCl0zuSRIeDAXaigZMVDexACrS8nOjhIo/bJWjdHvwri8uy+4t6lhTncghL8kcd2H/20nN7T1+8cPLgwaNrtu3Ih5dBGvqtqX312VWP203c0aePvsufhPfeMXXyjPDrsPuSuTX3IBSZ6W2X+OWaOkTpxIBFrzGJOg0XZOwioyc4FBUUFfbQZNhtDELBq83Nzcpk7TZfUalXYK+GRTAaFD70cdH2rptufv1b8PnWB7odcrHNYBJYPmXcQwOHw/+0MeHTfQ4PxLNLeiK0Saa0qca0AR4NALUyX1OYQgWmJR4MzMAYKzAXCe+DFPRrUEft3KDtJLXvq0yBuRrbF+IiPFer0FwJjBmvkYxeBDoySeo1ElHHZ0dTgn7XgSp2Y3jRli3giKY2nBsezZ9suQyusCkSR+K2DIjWaNZZl0nEIqhxihrUoFk9635Mdb89q0Rq3ekjrfuy7L66RYtoH8/B11AvcOgW0J+dGWJF3Bs7E07EvcGxaHwEd0IDH6XlScKLFrWukXBiBSYTLzrkGSw1eE13IIHRaBgqLWjkaq4k41bkpI47GE5hC8On2C81tSFYFYLjQoyEAZWGHDrjaYTCUdqOwgxUYFojMI9EwxQqMC0dthOBuUFhbDEwmqFktcmh+j+Nrm3LyWrDKqsNiFkB6pBuV9rGa1ua3ANa21i6tgEkv9FrG8ZoRrverv12b+i542RtUz2H1rbldG1j6doW76mRZG1T9waZfLq2sXRti/sUkQFKtZ/TsF5mQfTaFgt1NR79MY3I+kdhEI2Q5o6iShyOuNbhTNbIMAITgZkbBUPWP9pOW2w7mJfR+od5OYXpGkhW87LNLRpt1clGo8LUfrIExuHs2IWwRMXqkVWwd6nC9nQBvOuO4TMdLmUsMxQ8Yb6C5zYFT0nm9ExywBolc1TgYrFSUMCdpoTCTZIWX4G0eDLWLF6P6PUycXU5bStGn7uRPu9ZakernV0Q2ObwGjAcdH74QsnD3TZVnrgAQkXjc+Cn4ELn92XVftt2pNq/bQufNulAZSg8w9xd1qcriCSXUUmeRvUy0qer1Dp3BZEkCtMSgantCOYGhcmIXQNWkDWAwnw1n3BbKuG2DTK30ZbKFKirsb0hytUi6mcTjZeMLECDyHGMgGivk0yDIrtEfewLIY2MftY2srrGRuwMhR9hxRsL2JnhXXit6IdaCqKWnMjiKggkGDmvVrSwLm+1yyEiPW9AWt6mbrWgCP0h6/kSP7I2/G6/O4v0gSejdvRo3BP6Gb6OnS/uP6Ev0X+hVg/ukcvEdhXBntCqn8qiBzaNSg7qEYyOjBCv8AxAXMGTJUcXWeH9aO5Rl4TD6sEI+CI3Hb4ARiFfLxRquRyS/D3sLZqZRGRNJniMOtFrsYqspZplGZcRNaeRVwjCZbRdtHr5kQDZ0RB9dhsowWP1oTH63WwNnN34wU/HwYaW8OHDrOmJ58HiN4GLE0KtfWAZqwmxxlAo/DNZR8gIiNbor/IHgUmj0hoUZqAC0xqBeSQaplCBaUctBaZMgaHWPhvpLC7U1XgYIY2oIxqxv8ojiNWIsWO71uHYamQYySMgMHOjYIhG7K/yCFTtYE5AGhFzQiqTE/DYPaLJXg2QGZzCmHRBmSnIxBVhoziaK3ztVKGKT+ANtTKUuSZGF9JRzFAwpFY7wVDRhVhiMZfZsS7kecZiRCIUZLSyCsPKEOmvTLbE7/JgG5hoLRfPDv0PbHysdsNDsJbtA6ELaL57ZP+WNVxSqDX/o//JWuWPZO5HE6/vBtNAKeQxq9cMhON2IsOpAavJyjlEjtEjdWCRBddRLlnkfns/1oGwYLUgC02J1l7XuOmdNYGTD20CM36EXwe2ViL9wJg3fAh0tZ/A4P3hWWxqVhctLCdrZQbuBeFSSbVXPuEMN+GMBYQzVOuChrEH9AynWhEkfeSua8QGV0tRCLV5n7Ky3kI9dniQjk9Q+4R03cxAXghZbZAyQP+App3Xirx6tQFOPwdIH+yNoqaJrTdQT/w+sAyuaZks94hHQVf8W+goXGQUWtUo5BVQgdKyTzGPgCCGMwEW+XQBebS9pNGamdyABxh4La/T6TkW0R9zpVFUFsOCIr/di6bAZ9eWlCIUc9wahCbgT5xoBNvhHHYlW1j9SjW7N/zW+6+8D3NDqG050mVFVq3dwJureaPIMwKrUvOoXWpz+5x+J7bmkZOF3KyVoNse2x7Q7XjSniN7ktCMPsHOuLGA3xJuYEe21GCO2Y7aTiHa1Rsw6jldTKuUVwCeryyQZd/eCo64jrfCoS5ExUa+DLVV1kJiXqQdMn8TonSc2jKiMIUKTEscXbEdzUoKoTeF+YpqHbMuirckKOSJIIo4OTvG2mQU7aZqu+ITR2OPvE9tXmnPniUlkXEc3L3KsHj06N6R4bj2/t1iqneYZk6tIgMDbSulnly4J4tOYwKMaALVSOMYiLrBPdlJTxxqvkRFK9LnIsPiXQrNwMHdMKPe4Tim+VImXutK+M2f/26KUGeGMnJZv6ijAiORFpiJ7CQt4gXsz+lE3iTyyEjSy/4cto2wz5Uj/WarwldYE2sKXwG94NvwbReLTL9wSrjwCJvAdgk3hb/BfZN2yexNV0csbbzKZqEwAxWY1gjMqmiYQgVGitC5YtqRInTT40XovHY5ZqY8JT2H1iOl7XYRugwCzHqI9C6LeDEEo3a9Xfvt3tBzNEKnek4VofO6SYQuzlMziRej7i0SoUPd4QhdvKfIajw9KkKnkD8yfmIzTldH6NQjjjOT1zqcyRoZRo7QYZgJapgLwkIJRou08BZ5Lhnmgygo0ttcFd9wCVG9IbxpS3NVeHNp7fFWt3QtXksEpkaGkfAmMNF4Eymaq5IiArMievwRGv0Sn94Yilgk09UxygglsTwiiwTLYyLjY9ICDkOaaODcjCi4q4Uk0SLoJQVRgZckbHaUlmRTsdRYWDe2AJA9wsmSum3+8iAyHZGwwr/0mDGg2+Ccrg7/7VRsYdUdk3bmeruydUR6X7nLnltRltQP2SfsSEWQOWZA21KETyuyPxKYdKYwkGpn01ypbqNOJwDGak0UrfqgQS9MF7yiwGGVkWQ7iRBEPxx4TfLmlebi6Ji31Kv1oD8y8ziXF+RmZYAMe3Ee8Pxz/dp7WFN98Pb1i1aGrzy7IDEXnBg6D74NeoFeBbDnsHUjvm4Ak9kvR9aPOPkK3BYuHM2uenUplzqw5Rib8K/7Wj8bguhKcCTUX6TmmQyhHYfOUGgvRUhtyixKunAkor0H0d4fyEh02UWzTTSb9S5dMElvEvVsUEghw/Qq5leBtK1DooI4EujwF3n8qohpppBXVGqnUUIHq3v/22/f71nZDWxRoqc1WRO65adlda1ZutIFloDx4Haw2iUFUl1HBD7fA8/Ba20M/Ea2V6aTmJkT2ytmPcKPAaZ43nEG73Yxviy7Uw6O1oE9gAPJ8CsY/hj998ShQ2iR+up7eAMO5U+G63ds3L5H1YOJroVWo8hZRCtn5RilD7sSG0Z+i1/qxx3pp/FjwIIU+CWESj/NNy6ijpq5H3E/Dz9FOL2YcLoNc1bAqXWLWg6Zlai3as4uGjmZ1XE/iFsUPnfb/H4tkFic2wNHw8mEw2+5NMsFZ0rMXQyO6G5i1xLWXtBPB2EDW6NwNUu8xEVyxDng0Bkdlki82SAv+O2izciwzczy2YEcZK4F35z7YdlCkHMZtun08ALIwO+7167V1F44+dh7PcJ/Y1PCX/InoWlFcPl6yTtdRDh1OeXUs4QLE9U2DYUpVGBa4sEgG2IRsWkozFcGormTou3l+xA/5yAKZyELMsFtTxB1mQZjepolWce47IiLBSUOgmSVMnBeqcfjzygpzsvLxT6NXw6JIFfH4/V6PG4bm/djQ9K8f90OXKuubn388ifrTk6rrdw0YuF9w4eeemKfa/SJ7j3evrd3zYCjG4++O3ba5qH9/3D7oPGZM4Yf3QZXYKsc40QocJ/aqsu2q2SVwhQqMC3xYBAFcsjaRWEuvkZgOqtj3rHtSN5t/q+1QykJclRxExwTQS2tRZTMZPICibpk0WvUpQga3uISLfogn0YMJikYXIBpiXnG1hOpPT/AGxR8FiUsYZq8PKT/cgW3vfZnYIVvAPjNk8/C1kuLb0nqeke3ezctEP8KMiZM2P8ItweYfzgA5+Z9svfTK95XdYYNy6ZvziwCoSLwWH3rVJXtZkOS6gs4XRqRdbkYs040q4NcNHxO7DjkpPpYX6Y2r6efGHROn4NYcyzXLxNu2PtAyq7DbA2y69ISw1vdLvZYeu8UcCLvuW7EugPH4EBs31dK+kHLOAMGATskkcgJdkKofwyuoEXaht4nkedbpH7OiiXOoBVEC3rWyHGMVn6exvmVViKeNm7tXVBMW0S/32UrG8CJUAj2bAgfxrNI2iYzfb+aY3ScSmYq0UxPJzJDYS4eJjAWBNqjI5ivWgg36KPlCnNDNhmJ7WUjzyKbGTmPFQUVfkJkbKYjGSK/BXYsLGtcvh7wjZdcoJl7s7XP5i0gDf/+/nssx7glIg2b1dJgU+NNYQYqMFIcx2ZUxXEoTKECI3G6y9iunTIFRo7j2IzqOE4tInI2ocBmdYwmxiaMxftah3jXyDByjAZ3N1eJNSLL3SEsRL5QcsBmRFrfUm0k7BSJ0BZEExV5RH6bVk3Zvq8c/z6auIa01+Hnla2vf/+9hIfGQXB9RE1jjzVKn07GeCgw0qiT2406qqVr8VoiMDUyjDxqN6eKTFGYGUo7kl+GYbapqTdKReFf4s8WpjGxKDerY1yRecA0RhYl5tYMJjVgtyMbJgWZkynVbsEiEnOywE8lVzEnVQystirZXdianEe5GX7avaqc2pPUkPQkg9fU7A033mzNC/iJQRnhhjkKpmHVeAZGj4dQZrOaMjZOFRHrIu0aYv2j50lsmqqPIrxb7wN+8kLaquYMGOkAI8/AGmTmpPGf31iAnnahp3cR2U0JWHmtmTNpBAPe/JYjFBXEbvVzfqf04nxcFtdQd3qxa3Xjfa7Fp+vgO9WmatSki1vTuoy/dGMBN7V1D8aetE3mbE+UNKtXbgpTqMDIkqpvB1OmwCiSqlfPfWxvsgzqVXM/AMHUkFhMUsBi0AKe1+PAhl4Jx5CxAkD/zwJgAHgBjroIeoAeF+Eo8MJF+G/4b/Y19l/hC2xG2B/uz7rD36F2E1G7j5IdGm/ABHQajtXrglqWhi+kYJQ0EVh35zSDiQ4wsRnmgGvcw+Fe7Nutf4R6NAbSDhlDvZpiBlZFDQpTqMBIFLMI7WDKFBiZYgZBTbFEpNseJbqtXi3ltuj4cyxOEl0N7furkWFkKccwc6NgiGzWq2UzzthmKDASv2MYhd+RjuC7EVonBiwCz4k8GwQ4AEyZnkbpSgBeLIHP/Qi7JVzDrQlPZo8c5tPQ2vv5YdQPaYOM6bkoOvMqXChMoQLT0iFMmQJzNQ4Mzpcykr4Q9+HMFdgkxWMC6DOOWaQZSO5TkjNq5zUmQ0HgI9kHMzuI9wl8JN63uIOIkQRDPD2lnRjLUG4HW5gzO6CHDIPHulj2GDHO6/huTBKTy/QIpDrdLtHjNgQzhCxRh7jCYkYuO85fSWCMkjfjKLcTG4ea29TG9hKrsNTLe9x2r1uTlyUgnxEHFpHlneF2gVN/ff3nzxZPfPgh6DoDtG0N8KDBbTwoTrmnX9ld5UgRPPlQfUNiufgHXnuM4z85DQd7Dhj+s3TpgYFiWcCqeWKXTN11wmQ0mlfJzH1E/d88CwDPq/cZ1wk3KTDnLikw9VEw2q8oDJOLYdDcfsQYwP1kbssLAMgdF3lG3p2cHGlZibTh9nGkzU+A2a6xkbb4fZ1lEuW+iuP2hZ/S5cQ89Rnq8Tef0r4f89T5tquRcTG2+E+pqPoJpVhBLFXf0B5WWv6EUgzcBcbieGG3fBwvPPvyuMhTappNjqHZJxLNSglwRzSL7e0sWP5bvZHnLsc89xm44/c8p3PFPIfpdoLQDT0IyuI/pflcoduZ72m8TCFvhAJ8NwVKik92jbbKYufgbGJHnL1LgfmM6QBGE4G5cCkGBss7sqWwvHdhypjiQHo+kne3QShRCXsPpquYnCEmd6IS/24BDSQgoa8o8Hck8lohditR+5tKIGvyHZENxpG/qRCAMH443XwcOMWWzKrVg0KfqcrYP70UmY+VkfkgPLJAmetPFdlPYJIa+N5I8x9p2xnQj1M/qJqj4Ur7568qtN1FacsxbgTzKF/GdGIKmT7MTYE8T1JXMY+xO5OSGKdQKgpCFiaxs7Po1AaLmR5iVqqYJevVImzGOmh6dXdHuaM8rn71og8OHMjxYWe81CtgemNKg0z0b8W5oAjTm0Y7QMHarW8cHtJ7V+1U11Sg+WPlc9ue5DhY4nowWF6RlD+h07LnCxPd94OnBg/igW9Q+K3KqtIxYyePcNVt2/+Su+QPC3juJU7/3D/g1R8zh6at22Z+RmdYHKxZym3b+tRTW8MJS+YOd1VVDr8FUYeMnHDwaaqbSe4O19cp613EefUIplLTzFjQWpMecJicImMyBq1CosgLWmQPSPvU6EX3Qv14qDipJTPXaZdDD1kZ9U0u689N38BT8D8TDy3tOqXbEwfvXQh/1DSHNzTBixDCn+EnRnYKvIVn//His3iymA2o52FoXhKx/WEQzKIedcig/o3qfEhGnUAjEJ+hJyYwewC2wC+AF3CPn+u+t2vtrQ/tfam+cveIhPFHXCAVGAEPMuZX3zOs8sWnX3zNYjrqIDtXpE9CkQ8oRSpptqKgWoliYZqL4sAgfx7hrsBc/JpmzqijRLHtfELbSWvXF9FXFObDQqWvJ9S2gA7NkJ3mHJkMBsaLpkeHqOVhXKJVYlXyqqiIRIu9eLqIvAObP6MEB8kFVvjnuU9PhJNdTSFHgmEHbLgKTPDHhfe6ECE1iGg5TeziG9mGQ5OmsClwRwNgQOHbGIdFhEsuMalMPtMz4DN5rS7ebXZbHHbR4qg2W0SPGfG8yAjVTJo8gQUkYF+AkCDeAE4loIE/P5unycvJzSv1eHO8Wo/D7bYxeRn2YmmC2aHnfzpx9L4X0uzaGliYD+aITxR9/zDw5R+97WbY+iNI2Ljy3vtXuYDw/emLd90B+H3r/ypW9po5dMHYv/acD99/vRAzxhHg2rxz7T2P/hlrAERBzWyyF++kOWoMKzKMSWcxIPcsqEsWjTptkPeINj4i9UTg5f35DLLVoKKnj9KTn1HUNDHMwkrw/E8STbfBQ4hqLGyF0i7+UDaFLWxPVnlmg2hmE5ksplsgyWWwmxxGk1GwMEHBR8UhRfSoVJGjvByLYPQkIwNdymfqaLLhTjCrSRQ7mnIw9dCcOYda+sVMO0u4Mx9JqBtRzRdw6k2JosnECB4RY2ZV5hkTSpZVB1GEVA8SOeWoBmRD8Af40Y0vP/xOCBenvFk3YOWApKm7tt2zzcwmbVAEFrZeH1ax9n6r+ajDwG3bufnBxyQZySdydJ7KLJEjNjVWjvKJHUhhzrkUmCeiYSLtNLs6aicC8wmF8cXC/IdYQuepZeKidtej1KLJTpMtGuUpWWdMjrSt5LbiHrDd1ZUAs1mxdhfubWC73s6CP/9Wb+i57cTuUj/3GXjgdzyXT+wu9XPnmTTJ7kIPYrsr3lNEj1G6nfHQdV6ZgLhQHzrizBKmEtGsFIZmt0bRJc48ne3f0VzuUmA+y+8ARhOBuRDLE1gKkG2GpSAXeaB5Aa+pMxGCPCwESeliEqNIgu1dZZcsnixEIl5ZNCL2a7Lhv3MwjYLlzV8eTKjpUE5MeYPo5iqOlbkBFZrI6IcrIzufpoxMydGIkW9Ok4RTYm160Ybk29NOvrECL/WRdVib17OnH4+RRbZkqQ8p7eFnLgnsuxL20x7vA2wg98ZFhHf4IsJbcw3j63IcTrfDL5AtEIbnj+7cvHkntgMGIn94puYyzVthbU6Rs9kYrVnUgiBjkHce/Ur0vgSrYmwNZNjdJIS/DT4PRoOrQdFTMb0r/BI8D0ez6w49wua6jugEuKfuUHgpsbAzeR2xNrKYToFElxBMt/lEBxppmiFF1BrQWIHIWGXTQ7J4nHk5JBEHG3Sywi31I5NEwylq9iUDGPvUVodhx2Kqbr3248jeuXhU0rMw85hN9+e9syZNURTu8dZe8Ct4xcg1K8qWeCUIQ6LDflJ7ydk2lXRQmMkKTHMEpr4jGMl3zG8PU6zAfH5VaWdlFAyRVgrz4X9i8FEyXpsZB94ztgtW2Wg0kpkrknNeid2I9zrtWWSZt9uRvegAQv2RppkTbxAj8d2j4dHs83fMhafCB3HL/aSWk/CJqkSLV+QMWpE1GDRGizaoYYJOpYfI7o6S34vYIrY/UWwCs+DOSK/8G3jVg3uie25ra/sbyZ5cicb9C81fhEeZSmyVeWPz+0ZrrjBGukeG9zzt0+020S4EnSazaDJIQbQk20k5pQIbP8hJACXSLpSb3dZ3/Pi+/caNC58C22E92wUM5t8l/9Cv7/iW4kPs24dbNx6SsyVH89kkLmrWIk7FOaSCLB+qvGKcqyi3dYhtPISfl3IDRxOeCKvtXoMGgGPyfFOYmxSYc0UKzPPRMJF2JJvW0q4dwjcU5kyxFDOVG1JOMSD6IahWqucHEz2fYmp3ikHd39lpHeG9S4H5bHAMDMMzjTCD+4bMFj6jl4ft6JRUMcUadKCJMzHTMxOFYAKdsqSTUk6ues586vlD3MyRBD070QRgsjSL4Kg8nTOa3jU0PrW1qY2BFyMzGplZPrulGWYcc1ie3MtdJMog7FIoFxnJhaLYkbDkrAXluzxkySal4ZiAZ7rZ4xRNHgPZerdTLsQL0kkigJgFizriwfbZxnG4Ep5RZx3H4VF1AnJkToYrIznfRxnJfnkkB9Cc1JKREM8To+6a7nKKSDVjAaKqOJ78UNqTdGRB0LLXZXRXYJrDmWxNzffHIjj+MvaYw/rEXq7sUGuvv/13iRVJE+55MZImC85M1GmRK6VS/kTrR/XQoGoXz5q6NTRW1Bo/FvMoMBB98QnzEo3oOnXKvFEJXkA0pS/gsBg5Oz7/gDpGytIsq7JIXogfZ7z0LPWzWuDjhKwse11TrzUHbvc29/g7KIM3fh5yyxxNc+uCSSefgUt3h9vAXjucR6UqA/eCcDHRfeZLZCfC1T7feQEavwOfJzdaKC56ICiYkFMTvxsTPht2icYE9VFFLCvstSIaCxpRYIKMSTEpaAyFUlgOmbCXjuyDjawpY8qkW+9LuPlhV2Mz98ShltBYsSj3qAfLB2lTuwiNzkp3G/YQvewQVHqZwBBfz024Cnt6vEEvGpggbxN5lUlDfTuuPR44D/toNC6yLxeNEqZ4FaJ4PqE4xekroseAM/p8jEQNCUrLPgX6gC7kjALWd2yDPDMy1RKZzoFELWtIxLnZgBGBxm0V3cYgVvuMPAQ5P9tZkkNGgPOzXaoAVEnJIpCER4EmqlEeybgj+8A/XnmITT4U/vPeV/bC09JYGptPoP5rELECyEpKZwoCXq/bnSakiAazmcOruhB0JCZSBsGHuIrwT/yDcInXT137nkRI8bKblan8qjlmsZkO3DTBatdMGDtvZtMtsxvGzuKz1+wYObLfxEVrWt/gOs/b0nqd6zcR/ZStCoRFtFUhtLcqvLGr/HG7N7LAZx+X1vbps+HHZG2Xzm5gWfXQddBFJVVt7zMUBnGQB60TbrfBKeoMWqwhNEw1WnStvEHOICN42BEXOdvjMvibWiEKnQuEhTJi0YqDVfPVGKwwDOIzHfaLJBgp2zxGsiUopFF9AZfFKlqswUTBK9NPMhfkMycRnG2slHIeS8fzP880rFpWE6HmQfhVG+M1ESXILpCMJtDWS+o3GfdrMwQ9RpeoN2qDQpRmpTa1vHbGEgyr2mO4NzXVZvx7L1a59l1ooTyuMtWg4W/fLlbOuuCVRqLLeUn3AtVKI/s5ePXHuegmUXCQGIZKG1Hr3kE9mhIlFlXVfOVK87mffjq38N57F6K3C2QAAWhBOvwM/gJvwAuhYwefffXVZw8eU3ulIE0Vb2UT4kYqJJhzjALTPlIhwXxCYVJi2zmD4wIYBvvpDI1CrKb+fXqi7N+ndBCFkJ77UukBRyHyaRQiLV4UorBdb2fB1t/qDT23Ekchop77DCz5Hc+RKETUc+cZgxSFQA/iKES8p7DlKdHtDEujEAnRUQg5wiBBSbs/aR1EGCSos107mstdCsxnrvgwRzQVEoxW8wXS+6S/BAFXWhii7u8I6a9AHavPiI46T5baKlBhzuW2x1zdEsU8piUCs0uBoZjHgxmuwJw3KDDbOuLUjwdHKB7Zb1OiLBLUBSaGTqooSyrTiexDZIsmbTCRERMFIU10CDQGSiIsSkZRLltCZdbFalVJ6mrx3T1/efCND7AEP1LbaVIFDanMkWRZylR3gJSfZYn+F/y5yJY7QMpXv0WWbbQWbGhbivA7hLOjmSycr+5kMz0+r0mv0wJkcqeIdmPQaNBO1yaKWm37fHUNyVfH8QOasM5myRnrmYITY5wHPKBr9fiHrjQvnDhh/rTtP527e7KvEyjr3m/hvVcW3tsZvtVj3YhdW4APo9rpyf5/2QI/xfqnALRsnMAWJr8a/u7YwdoJ4VOplOJLpXkpVnNTtrYd9w5XZoXOL5mVbfLemQvBPEL0eibTmSkNZOhSRB1vtOK4l8BbrQyfJ/LaYIJDTGCyJOvOT+0rullm98snfYribZLlRXbI7Da0CNjAHFgPql4YdsszMbti3905FORKW2LvbdmyB+kGNvfYMfUu2KlT0h5YFzAbzIY74A68vwWL+Uo0Arx7khPwuE1e0WoyBl1oBZBXRYs66IPMKcmacZBZys3LsoMMtDr5itA6hRfG5PA75879c/GjRhewwB+B6eq9sFhz+XgT/AT+DFvgt1MmhbdoKuGpNqYBzH7pbRkHaQcnHg5MPBzsHeLQ5IqHgrYeb7V1iEMVwoGJ0MFkCRqFIN5H0kv7SBb1PpJ6TSQRryx71NYCgEqsq8kVd1Ph+A0bWxO1n0AzdVciHLwYAwtjsItaZFjRUIYb2wly0AS9SYUceorZ6XdgQyGLSjXyWSsvvQlqshMcwLFv++lBo9avBTyOdcDLIPvY6QWzvv4AXjwkZ++uJFLQWyUFIMGgkoJYmGYmDgyyblaSFaM30eFftY2j1lditPW1C0mLi0SKMwMeQ7bZ4suwp+oYV5Lo0pKjtbL3QffDctW52zgtPluKbEay4l0CKyx+ZkhC9VNDn9rqL7my+yFE3E7b1nluXtb7+boBA998+vEbLovtuM1WMaiwu7lf/qLFh3bhuGffQd062Qvz16185nE8AoIZGWUFpQT1x/NcqlHGwjSnxYFBlHARSlAYKTu+q3rfM7adT2g7Bb/WjpQdnx+dHT8QtVSrucyUM0UBH/aCgFBmCGZ5c52dbeau+kKDkOQTk4xBwS8KQCGt5Nw5S/xKyEAgiRAebxqLi/rIhMd074Y3JbE9iv7GzJVlH7jzvx8eeCW9u9eZ07+g4LayF/88ZlmPhGE1BSuGFeWP9hclppYMG1iztIldc/jGh9/t2T548k1Z2cPKe9zWPX/SXUO21dksx632mmHT8rJG/GHo4OpuXWYNK6sAq+9uaWTXqKLdNuzb4CR3rl2suyA20o2MY7AfPgFmgLOL53kG3NEdos6VAHdrF+xv9yG54zORbKUG7GbkcBsEXTU2v+0K2/nl3AXiLdIyF8p+Omf54UN4FRiawOcw7Z4HimqGJgxei7xCcPEQCMDjh2D2iqBRf9RkUvWVjiPpyS4xGXVgtonAZK7m8XEmrajRC4qnRrWJswSPSOqWvJSuiavaBxiU7tUojPjhQ3D50FmKxNlD4yQsGpunY6uBYEK8fazVvHbk6CM9YmCqLQZTtUEI8m7F5ZezkdU+fwwN2API8x8ahw4R9789ORA390HcjOiBuHkIlYpLdKdfLRWxMF+VqjTIBrUGWcdn45NiAacVB/IMQTMvBHE9JKdKQSsz6bdLp/P9coYfuPH0y02zpy5Y1LQNHrQ6E7e5/vEieyw8cNIfHnqW7dW6y3PAcGbOAklOSX4TGKn2hb1mVWx1l5y5J8Gcu6rAPB8NE2nnEwqT3K4dYplTmDPXaUxYaUjSCjgvK1uB+vJzVa0Rxb6N7e9sVkd471JgPjPEwEi0PqOpYNKYzoEkb2KCmGgIWjw4n8EiYJon46I1kkVTVCGF2WOIjjWHH5k07YgP8qeMbZ6zKN4UGLyrFj/yes+wJWomzpARjVXPRDqvHhGizRli+49V0yanPW3ULWHaIKh0B0C+xlPRULsUqM8MHUMNV6Akzxpjtb+juf+4T2Rej0XmVc6Ak6AuSFzEq2eDZMBlM/m45ok3RfTaMftnS/yfo54L/CJR4fYS0EHCm0omotPb4spHTEqbWlqmKmP49GpkpBujR0poNlJNM69CM/m8EhoprgVq4BmEnRyZKbJHnTQ4BVd+DjIdIOFzuJHPbt3C1bQ0o+eRi8WL6HlcY8Gm5c2cgTGQRkxK9FZKuYk9bBBa3FjpWP7GcsfE04/A1mWmZajVZfiwAbempZkb3voSGgFpnczodDUv2tQ7LrEwksS72sEQiZ8eJfH4GEFE4mNbkmQ50hsaLw7gDkbjpWcNgJacNRCCenm0ylkDp5OcNeBEcA9cexnCy3AlWHkZhn9hTWwCfADMD18OXwI1cAtutRTp40moVTvedab7DVoudjLK8colz4dFCpKVgnNwYjOYaAVcMzzZ5+F3NjcY9t/753KJmL1C3yywuUIu67LVeISkHzLCWZSexBsHDjWtYmE+sSoZ6tEwhJ4U5oyd0tMRtasmjUqC0mq+BBMoBzpMaLHsqL+zfTrCaZcC81lWBzCaCMwFircDtGtnuAJzPlGBUSQC70eYyO6mfBJBoCcRZH8g6iRCHVsdfpSrCj/Nzj3Mvnn4cLjPYWnHyUTGdJfa1jfwMTuFaphmpgMYQmcK8yFUYJ6XvWKcT8Yr+WQFgSSLg4Q5GV1MOplTydwiR7k7yiZDpij2fnlH0fGJ4WK4Cqw8m0Czye6D//381OkLv5FKxjM/IiovJDFrLYly4jxBwtMahBfPTHcge0wXu7+JtYJUfSZqP5M70BQCxehHuK96H5PEr+UYdtz9S5rxWCNnMwpcnOxKGq+tkeO1AhcbgVciEzVyZELg4sRRqZdRI3sQAhfHo6HzXSPPpdRO9HwvYY7xpfw+VuA6IW4Qrh1BE7xDU8v0ZiqYm5ghzAhmDPNU4JaunTrl5Ph8qamJ/kCgomLo0CFDRo509uzVi2UFwWCwWJx2seimm/r1GzFi8OAxYzxotvPysrLS05OTPQmi0+P02BLZYBlCiNfpTCabVA6WvqRz78rn6FdH/x55IelwIv0e9c4q8ZM3nePYt9+dRd4YlkNvn8/pA/Jv9O6ZBmenHU6DrfiH8te+F9Leu4B+Ax7/2NH+LxkAQa/Gz7FD0T/D1pae6g8XyS8coIl+HyD/x/4rfR8g/+O/WEf775Hg/aST5g3P163MeGYSM435A3Mn815A7FteXlLSo0dXOocDbr115Mg//GHy5EmTxo278860it69S0v9/u7SjKVliDdVVo4aNX36lClVVePHz5yZPHj4cHmWHQ6PJzlRTEtOS07wscGhynzaXK6EqDklM+f4tXn9/fP7W3P9++b898w9+ul0Rnigi8IDcf6K5oamX/srmi+6pLFrCA9cfUP1ATTgB7aRv68FO+CR38Mrv49nIrzDXjvSVsk1CWOZ7oyfGRPokp0nZm8MegsLtUksqxVEj99vcFqtBiMOVxl4u5kNdk1NZsRknp529OMpVM+08hvbqHFmRp4BX0kmjmEzPr82KxMnuvv9Xkz5X77sCltiKbzv+fT3zqdpXx9XPw/cCQYVunT/hW0A/Fdn+XkU4NNhy2Fk5MSQhpLAtReUfgr+Cj5qgGtgPdwNl2xj38AjB1cvSrZkd2ZioCvVb4nubhK3S/rL63U6LW7O1skuBLvI/G5gKiSGpBbYrzIsl0XMz8hbMUtjX+T7HU+YtsPWelM9bN1ueoL++HReY6VrZ/M+1yH0PtJ8xLWv+RB673RVNs6Dn6IH2IvhJPWbWGOm1ivt3sjUxd+jeQcpnIb7XINr4mTiiKTHlcSIzvSkaiFd1JmEarNJNNvl0+K0giSInPzABz88HrcbOR3SmZqSkqxMtwv8fGdw4713DPnrK8Y9Dc/+8RdNcuKk4qqq+qmc5o7Js/+kZedy/DYAHtzwi7lGmN+n74ZAdtHI4QgblmO5QwgbaZfSxIgOUzXeqOTkXUp1Fkz0LuXOY8d2Pv7qq48PGTduCHpz7JFHd7z88o5Hjzwy69axs2aNvRUbX8DHebhVqAe6r661ipyWC+IyYUAuR0giJCT+HbWPD3yHDWbN2CF3rz46fzHnYVfM7zvgnrvgdLB++Wa4sa1NvqOAFUi990itFwsaC65vbFPVWrXHr29cRMKdQlak0jay8WrA8FWv//GPr6/qBS8D24odO3Al1u1z3li96u9z2H0wad3ceWvllX4e6R9NLMKhAX0eIFf0i6rxKvfXwG0O90KttRTh5wk8PlsK1tLMEmqVCOoqtxhmnPCGdIeDRgRcdWx9ahxQsjewHzeGczW1oCc04QoVLJMGP+W3IWxsiNMQNQzA6hHNVka06oK6RFHHKrvjNPLfjytRSqA6XcjtQBRJm5xSkGrl8lY0hlOOm5Pyk1kbnIhrxXave+PNW9i8liKYATJRPw9Uho4/XcbbZKqMJFTJYZTPZJS0CkXHNYHLFJg4dYoRLZLbWviHNVvRSjswkF/RT6wYXmIwFvNpI0b4hoppPl/6cGwPD9cFOxeIndPxabZ06Qy3nxQ2ojmbdqI4EOm8JcSDR/56aQmOhOOMAKQuMQci515KQsLf+5HaxGFaXCPPjcWPfO/Gzj55Bu9T0O+zkr3OtNsGJSUNui3N6Z04rsrVa9uBbb2dE26bSL7IzqZf3DbB2Rt90ctVNU4TSssE+f2H8mwXVjM0APIz00JTZsOG0mz2zvBj2aVg5OwpCASeDQzVIBB+aH94FoFMvROMLM0OP8bemV0KG+6ciukTwPvlSNIKmLyAJysbny+zMKkuMZULIidTZBm9FMpTcr40GZHdgKysvJ6SdAvavH6sP4PWpCfha4G1wK9e2HJr7cxdz720/RHPj6cefjb3zpnZid5Zy8qA++pTR8SXa9b+7HrmgUG91y4K3nNMN1u8NWhx6I5ondbjjy9/srNJM/aJ4PJXZ7WvqSjojLogKXxAk8DkDDBANoDA9uMucKHpuAtmaGpbTvPdbizgu7WcjpyfHoi4htbk0EfOTyu1RJS6iyCqtkdU3dRaxFci4iucae8xW0Qz8CZwXURSIirTJ2ZGKigVlFPWkZijtBSRiTCHVouUSJYbZyMhBqHMQfZXEHfUNp6cMdyZ6+41a/zAwm7ZlhLPlCVFRSurPSWW7G6Fo8bP6uXOdYyuPqmpDT82ZuKROxYUhQrLPqgSU8SqD8oKQ0ULZx6ZUBkm+fUEUzKarVRj0NF0U2uMHKnisQ1n7WKB0CHqGkWBlRaVwh6lJUUk05DIOhL1nNmTPFxuI5zkHb0HhO4MreJyEZFPhp/c8tVT41CvK2l9TSTRVUSipZrK6HM/RjmjrqlDn6cTPSjXXMY6y8gjPFWakGZu0a5ruR2N9NIZ/iTViJIGRy0tZZRT9KTlZEbeN6Pf3096Qv3xO4jGx/VkjTqOlGEmg1ZKQWEvHk2VEk9555795bB3M5hmA/ZmuLf44f+GcrrzS1uD3OaW5o27+5N+cbuEsx6nnEVzYq16mbNILblLSPs3MGa0snkR57htGo+o09iBW0SKGjCCXHaSnJ8im9I4lIsrf+WU+N08Lv7ltOXYs4FNY+dZFgbA8QPgDdjvBrJB+fBMwELo2teFNbAp3fbt6xL+PPxzwT72Y7C4S+u7ncEs+HgBV9wV4SpVxUA0eTqK+lYmMWDWM6Jez5t1QRPPKpf20DWdxjCpymcHfnOqMbgCJDQ2sr4vwmATXLhjI/vsjQWsj9Rc+ZTfIFeYxoKqZTiRMVRHVZi205UIt1bbCGDjvEZcSBZPLF4jVFVacStmwQC0UTVvEXn8klxJr5WNrx54FTeSz5/F7xsL8OhWSrjQuksCxsaoJfiYqyNNFcgZgqpXltRilarNlnzYGSEnjTFbPUZGX63Dzeqk7ALVGH1kjKyuEe6QBnljAVoVM2UbZJ5Ubw5X4LXienNcVLW57kqF3/bWRyOokk2Pz0EaMT2gLnhy48aTQfZM+JuHlizdJmcLzotYOsi6ocZOVP0qh9wTLs7tV/qS69rduIGYTerszTdRV/zJUPu+OGXeDKS3rIDTyCDrzS5ytvbjkkxvoh3JVSaYXEDucWXjig379m0AB0PhyQMHjpw8GQ+u5d//bsEqQOmSZUrIbiWuXpuGLWStV0QzrLHj+tXWBNGqiLc/Ys2VkFrRkV6zcGKf0nHJ9CGs+e5Fmzcvgh+80mczu6Bv316DB4fmbuP+TRHgT7Zeffbtm1U4rJRwcODM/YCHs4taF7ZctaREj9WN0JBWhSJ1/UB71Niz1GM/2zhv6fbtS+GJs6CpuLjfyJG0wDxFAJd8l3tva5Nr3SGZvo/qOaoHSX0/p9WBOlfK/7uiyv+3q/4vaJHd6Yh3ocvzF71s1/DpXPBG7LUun70Xgl3wrS6oZzs5g1uHLFwc3TPiU2hum+jmgjyjxcWz1RaFOr2g1FdCDm2R6mzYywTN67+bsGXCphkvfGALn2S7Jl46tR31+3cQAMPg265xtz0wrPTaudCpz1HHcCN8Ev4FLpUjd0S79WeUSN5v1m+X6oyjp0YT+uHqQrmk7nd6wK51YH6Sar2ZlWmU/YIsUqfNrySJZtkvN3PFsOb0R39vnFlzGpeAgzu+CMOlYN2OjeEqxCuVUuU6B+LXroEUQ4qHI9ntWrNTNOuDODmLC6qsdkotr2znOBxyyg2LhDOnqCf9227zVIZ2G/c/c+TPfz7y7H79bvC/sSNGjEVvzDhgDOgOn4L3wLXwGdAFjAzv2gdBEsgBWvgL/ARehAivochawKNOZ/Kx3JqMPq/oc3mw/Hh0wUwXXhH+RQ1jYg0Sg7i0FHlh/pJuHHb6yDotUOsG14kkjt9QX14/Z3bG3GGusjV3j2xtBp82wquj+1j93vmbwAfAA/9z94MPakJ5Q1b9aUAilzLiwUXvnEPy7dD26/PulLnsBwAuX75kkzQrVWRWEG9FzQoOI6sLVdPsBGlmcCS7JKOkGM0MsNxAU7M5BN5EetzSGiKTsx8OgzeF2n4JI3egrVXyycx45oHeJPJ6PYNv4VCrSfV9PFKNvoYjR7CvBobCI+ywELs2BMtD4ZeJF4JWisPIWryNGRooMJQUG/m0UaN8w4kDMhLTtv/IQPVIXXBAP3FAHEekO84K8Kudkf9nT4T4Hx35IpmZsi9iLVhxYEUXi+yLdOmCv1gV0t42wdIFfVNg/b9zRrjOHHZGzmWmoQU+NZ4/Qu0GbFd3DSSp7GqyamT7xGwms1rR5NQl+X3WNRrk77OuR4duGZ34K8Y1zAHZtsXLqH2tsnSsmCPpwo3VvUmL2NEQwVXRFRGbR7k5ZGZonnx3CDV9yP0hbW1ylTGkk+qJTpKrjtnpmgpEi2BA/TE8ctD1krWG+vGWE+4EJf4SyYSVbhEB4CdVKbKrVxtBXsgh1yNzhOBHIA/XTFNGlB1wW3DNNIFUxjcZxKgb0iROVKqnUd8rpoJa382hQEwNtTYyRFpHTaaek5zbJ5anw1rtMIuOiP2pnIKJskApBSNWKCKi2g6VCOmLtW4V00ouAaeaF0V/43kBCaRl+A2amPNIdy8Em5DuvjXO+hLxZTYwiv+I656BqJqEJvWNb5Gq8yays+sw2ESDAbVLKqma1aVLVRXoQQbnY4FStZTUoIdfJrPzkuGXID0xvCVRqUXPt8Je4O2WY+A4DMjeCcHpcYqT5J1oVCeS5OiPkVrKJk5nMIoas9nAigZdkGMjljLe/Xfa8b2ANPiDbwJMuxt0B5mg+/LGcAqY9R9w8T846iMb8/BTgW35lCd2c+SeUGdAL/Cq60GV2wbRS7pZsBkedcCjxOG70JJBfCiRnydkSvW4kRy4takIP7RcekCKaGOmA0y6pH/h/It/Sf5TLk4QLUUelAcvmlrkQ7F59p6OHJfDaxdYcP3iqVMXQ1+/997XF+cvXz4/vDi4bFnwkfXJYDyYAGaA21PWr09G1sVu+DSsT1rP3QK0wJ7esj8V6MOt8Ho6PyEd/k+yIHC1JoFUB2KZpehzH6TLEpgszN3OdNHqdDI6fMNUNZOoPrVOco/RkEpsTE6OF5ecdEuBTZfqlIeNFf8H2wALksGfDPDY1qeHeNOPrG14+0rz3avXLlmzxQX6At8itLL3LKwIlSaMf2jBjLuWXL3wLWw7Urft/oc3roRHEf0w9/YhWRlx7hoktdrkw7od3jWIFrvouwbrWc/eF3Zs3P1s/Y4afMvg8FsmdIKNYDD6zWdvWzdzvsbJbVi69iFu1uWK8vIKWAO/GXbTTcMYAPrgGnMIGyX+qRz+IbmF+Nh8H/bH8Od8dqh1Z1sbhSc74/+gu+eDlfinnIdBYAZo8qX4p0Din5EjyKRdooVRy/0awyf5bMDDfq070Yzlwx/JLoOFnsnTsWaHaMSrkCEouEVBiIl/0oiIHP8UcPgz/47ibmx4RWN49JHcLshZ2gJ/BO/edvlJsKp1JyzGSdDcyzuvTGHr5d1jvgzxy3km+ozCO8yv1oogu/4UJk79ChzPabvKb+K7/VbU06CKegq/GfUsUWyNEsXWcKtsjRLF1nArtoZbiXqWqCwNzEQ5Bd7ssX1zc/uOzfYWDJs9195zQcOCnvZ5dw4r8OTQL3I8BcPunCd9MXe2IZSSvg7ZGVwSh+yMdRnJoUl3HCjNBq/CQdmlB+6YFErOWIdtjCRsY6xLT6Ffw0HgVfI1pst8RD0TqbCF/LPsHKtFtFqZNK+YppV8E2MwNtqpTn7OysrDZ0ypOJLKEkU8kQv0E5k/S78bO2voK8OXP/jUPzsbyzZu6LJ32aA54xKHr64+D4R1q0ERbHUVj95e3HlU4Nab92VUdOnXz6xvMNhWb755k93V9cPaA4xypjCbRBVMBh7odEbEfUCQQp2O2FhnfZMLPPlRkwvezme3Qo5taebYVhjJYMA5kadIREoXiWM+H53lMFmGkc7gEBglr6ke+QQ9+E5MZ1zhgNhkHi/XiSyjQjA9TUyPPhbcsT2GFEj7UGd90/6A3z4ofcCM0QUFObmWwQkThj9ZONiSm+MrGH3nkPRBdn9gP58NR+UVPDPq5tSQK3NfzzIuBdTsy3SFUm8e9UxBHhyFR4KxJCN5X50PVqDSDEwFGq2F6D5vwIwDnDg7S07n9xdIUYFInFMQKion5bKwCT445GCodM1Ctici7yz44OsfT2Tk+BRpLyVgNXFmA7GUhKBOSXCjFlK7K4SyD9oOguwTSXv27Unis/EVQqjdfHyFUOvZKB5Q3UCnbrbdDXT1TeBIUxMcyhOGb2nGUsGodQxJ8o20rIqzKqpRHWet56aT1vBwkWok5zrJ+RTUUpmirYYR7fUBaXki3nUiLctV0SPnOFVV0b+Hc7hW9J4VCtF25UwwAeddKXlYmGvPUa5tUfK5lLymrgi11ZpmtP53ZkqQp5CQbDEwGYIf2ad6q6DNYbqJiSkpbkS/Cnr6t8JPdrvbVR2LPrpCz47gE55U3gFO2CQZTwLIXrVw0eqnHa4TLsfTqxctXDXmDi36WzsTHFu1clC/vuFN/QatXHVTPxdgQArIA/oT7LzwthPwGvwIftnGVI0LH2JvGVfF7SBHXQ6EGhvgmtABkhXVgEct5Q4iKtzByJyF58mMbVYtg/xcDqkBAyeoI7IZdmTS2OR4bCGsbGoGfFMTWAYO3bjRxoAbiA+WUR+Frms0jopmHEc/9dPJ9CS9Gyca2wQONW1oRAplJ55+vHApZ66lVmgmJ43qSnuysfHTmqZXGl5togmhUlIobgXhso7IjC9gp63QaKw5gk9H0diapoYDLzVNbIy02boF9sMV7AHzLGqXk2UGt6pnpusU9PxJtndj47HP4lHC13BrG7lFLc1oqbZgu+0YGmclakm6YQRZ4yYOB7EUSYmOx1KTSLKEjjWBqoPHjh1MgW+CPpVVVUge61995plXWQs8XFVZWSVHYnH7Junkv1W0aPC2W5TMREVi5V7kyOD16+BdoHvp7bdfSrl0aeKMGUiaYrrhlNmiMdjUgM3GIevYBMhJi8gBdXt5QcfR15qmKU8cPPgEeKcpPKh/f9VwsGJgM+GGGRMnzkAjwnr1IdSXFH31avFtozj6KijRV1nF/r7oa8WYXqx/NO4b/ni0Vy27rE+fIaNGhfpPYN+lCHCLwt+uf6xCGS+L95kIDjT66hYACbhqXXZOtNuj586PGSyKv+JEX6uafjg+h2DQ9ANrnDgR9Y9GvxEsghuf2Y0ozeBwGQxVVQ6vlLP8iHasIPIr14wk9apsTkR5pXCkR1U4Uoq+Mu3Cr57IUY+Y8pFr9zrBc/AW74vb4xWRrF11aP0DtIokwmKNdJ4cn7J3Gk1o2nEgNo6xEz8OWyrFYVnLfSd7zy7aNXndPjscAw4mN+5dvMbxp60gEfSA37qGFNfllD249tCaje43lKpZSpWYK2iFaFV29X+73o5UbQVRUk8oySj1lZCex/WVjBZWi5ZErQW9GFWBJRJTj+yaRddY8qsP8J86daoJTIV7XLYrTxxqmlh5kV96qKHhEAzic/tvs73Iuf1sNL3zsJdO6jsoUVrCTiRKawzSI7Qq3yImStszanXJUSXCzHvrAdOuJ3GU9qldhgfAidFDhoxGb8RgA658Ki8an/wAh+77y6tvP//826/+BWGzAlk4WMPh2CyyXw16n1v0+VwOLF4uQ9CRKToEibHssv0aic+W0IMGJD5L9uu1FjYSoF3h69TVW5QxfphvZ/3p4+BM0z39B2ZaC7KHzb4NrMHbiuOnTdOEsjKHd++WumPTjqfRyjLbkZ1y86AJXdgCEBg3ZvjNeK5wdQU0V5mMP5Dq8Yoea5DOlc+SjuYNTxmeMUouh3q+ZF0XM2PKFYPxZu6NM/MMtZPHxszfp9e/spqOOXQrV7EDpImUcvO7kfUU127Tm0ROiukK7Wu3qWO6oM/p09j/JFdVPX0I/DsE/3cITkAtdkfrzWZkFY/FMd3+FWL/fmL/EdTNGjnSNwy7WSPS8dSM+H1u1m/5WR7MUqQeckd+Fglx4odysSmDppg4Wt0rnGnTB+XmDpqe5qwYNmeBsXxg3cBy44I5w1Rf7Do9foqxbBD9Akd0l/UfoqGO1jISz63Lzrdim9KWl11H4rnLqKulGdL/7sw0ZCAY9VMn1+XkWbH5iYHunEqqfFAadUbSkxjrOfjSRF+GtOaf9FPN/Lu8B3Uot2PvYUXj2Gn5v+Y8wHJg1I2ZQfwHBddsEsd1ynFcgcRxDSosY2xvOY5L7O91jdtkC5waTcQKxydpkO2MT9LosOWkswR5FmiRU8fKTh3Wv8BOw6jYRJ7xOfJbfJ/DGaiRj3hv62muW8u3ME/Vkg1jabEE9ZzA6YCOnEMQgWRu2x3lsuPuK6GtEqHKsn8IvJHGQQL8punQIbPcgfkQ3kAm0oJosYbQIjvg5rXAgk//IGzlCLBcV0YVAcZnWpzUI1Wfa7n2j8ZZUQdb4AFCGHy4Be/MU5qTeDa1cs226TajaIvYugXIcnO0s3el6K9s8yLKR6xeifbLFP9W04zWoF8iaxC2s/EaFBWD+SGyV0hOipxSVYAgsdtjsvcRqdLioHlyVi+OIwgmMaoutLK/GanYQupo5uZyeI31qGq2zFpmARcsy2ah3zDDsqxd7RZu89Z167aGC/HP6PMs5+KfZ8FZBQjLIrLDmItXf5M5OUlMZoRMkqapRlLK6sq149MeqjifFHjMKpGCH0j92tjNsPU/4M1/ntu27rGnm7//0/IVC2bP+MNccfpl1zeABR+BH/72zIqdLgsfOtjYHFp999K1oTm3j5sKT8DO5BIM5eR5AT55zmWmp+n0pkQd47GKHkS7nHYnz0uK+7GlpUrMBS9k+LY9ZAJoBHWR7drwT4Or5+SdLen70PODF4+ylM8fjOwia/mEGfnwemmPTdsn11Un3Pov1+4tt9UMzNb7zV2KBw4BmmMa7snHx8zslW4caAnkDeudmPxyeopSU5LwxU+MElFDK9t4ZmCgU/+A2H+UsWepgR+ROSJ9tJiZnu4ehVX9KEMwgw126Sp2wcpekE3e/8uIGlJxHHr9qq6XY2pKUC1+VM3Yc0CZJqQpG9DT2D6yhr9swF91EFtDKp+b3/qANT+7g+iapO6teTlSfG0M0k45aHa7qOJrqSSPMJWpTnWLqdqI4UvtE6DKJlSnE6qyCZV0wlR4/tnayu3VGx+btmvSXQnnXt/0ZNlTxYmemUtKgeHH/WtTqxvmLf0GFr+wfWj/BxZPXtLnNd2cOeOX2Yx/05p1/9y79dE0rV0z4cDylW/VyCcgicc9kok6QcziOJkg6K5GnRul/0rO/UkRMcQNncm999KShtc3UiZPHRJrVyvv/1dETNPc+vCvRcQQltOQLrtZisjgfRYB2f2Gdvss08BskAlmN8NLDniJBHwWt26QNSHxaDyEPlLFNfTZzdBzsNSPT2DY9gdcsXqOPdDaWNv+ECvW1Dr+zBySp1WDaI091gzkQ7o8hqDLjE/UJiQn2xm9mCq7K9KxhTinal04WEPPqmVlks5H/THY1L1bt+4NUyc3vWF0+NYvK7DZprue24v3yEaOHT2Z/TicUlfHftlyVti5b9+Y2xAWt6BxIZOByWYKAolJCWKSR0yScUlJT/dFDvjKmBR0jItMBwmf7ip81jSu+DWMJNJQrOjtBzPJipyEYxKCxyB6GIQRY5NVpnLjQ57sesRk37MrPvuJbXKkvXDfK+/Aiys2rr/n3k2u5hPsNuia/ad/H3vzzJFFc+6YN188S2IUUn925MHinZAEk5jA4OqIqEuHevGQ+yQJY/F6feqdZvY6eNeR9HjNX45c+mDe3Qv+KM5H/YKmULuOJY+LVJ9MQzokQc+LyE43J4pmbVDLBAWDeulSZxBhLajyuNSHDjht3W7DA2+99YBxN/a43pB8LRd2r5AUbfz5nOxwHVGcLeJt4d27B5Av0w2vn1ohuRNaP+1o8PZqpYRQZP3MzCanuHGZDrRi0U08pMq9aZzbxUSfgTgDW488dNe87FmPPVkGhhvgYwPmBkpv6zLh2c1j4fUPV96/fdHSzVtdVz586d0Ub+KYKV1nLexpY5FLw1m6+Lv3TDMl9L3zL2u/gfDIwfs27ahbf39d7LmG2HMG8rkB/BmfG0Cjk/dgOSUSzAYZjZwDa6f6Qc/65G3Y8LvwC3Yk/ELaiMU7uXHy9qWbutDn59pn/f7/3fX+KoWdlwK/AhkJ4S0J6l3vPuDNlmPgTdgnzk49xnc7+VxJPitUA2+Qz7FZy1LWOfo8geA/k45XOr2Kz4vwokYDdHpRpwsqx1Nk/J34GLD0nsl90xrkitH7G5xwFN6J3jtCodhMaDXNwKMKzkp+s+o2NNy/neO1IlqZyIVoeuVCNHwenJ5Exl37AL4VDbwCh3BrwpvAAVjB1h1mE1kNQqEl/PXh2Bzp2LwTnC9M85YRTrvp55j84ZFS5iPOynJYDQbeCHQiskYxYnKqp3zaDHvY5IpFmxf96EkvWbSDn+CExvONnzXC8aBPD/AV2yv8NjxbxG1vndMDdCKfknrAt5S+8FkotEpoXThPzpaQYOQ4nLguZ1jiqH+RXdrR8cs3J2vdfrevpCf94HXPvgq/x9x041M4rxlfmnzlqL0X+ImtD1dBodB19OgY8D9wGdpgUtVRNPto3HLeAs6QyAu4zQK+e1pvYnlWb8SXY8t5DAV+ZPBJ93KQdZbzcfgUcw76/TPoiQSq5+n+cEd/WDaxaR64sh5krMeCBSbC/bwNn1w+FS5jG5Gckj5HSjkZeQEvjlhoGDPeKDdbRTNOOVYOKfnlm0CUm7fRm5zjno2E40tyvjCl5QXUIz6bVBWC40K0M7mfbKkfRFe652QWWJZ2o4sMzK/0Etl9Ir2MbQSBxkZ4PPwF6QJnM91YgDOZonvRSb3gVQWLD+1Ar2ToFkn1f3y0ppYb6XU6ipqvv2Z3fPttyzXUPMI8FGq5LA8AzY2iWYyIC1MDDmlCbESzmFS3lav0Cm5VKufGHoNVoB7UtzyOZyR85syZiE7Jxn20bo/cnk3GsYPcSEjiSTrAI43AcUazaFRyBHGWpnwPJD4xCAiV2Afg35uPOt5shn9rPYC6YgG3iaRfLYBMNJ0oj6cy3QPJyaliMhukvG62UW7HyV8ysxNeJ4YInpcSb4TfSym/4xF6KRULL8HreKCXm+CBujNnjoRvR1gcBY7e4EeJ8d3g6Cs3g+8J5ydPfEXCSp1Hy6b9Sh6tchMl2ykKSnUTJa6kABdiTcwk49ogJi+XJHKMDqlPx3QyqKSTJDYu2839WEeJ38Vq8V3SJIqbxyHb2V7XuOmdNYGTm9cDX0ZCY0JGy02P3YYYjzFv+BDoas/CJffDQT3G9IKDwf7sfoVgSV6hDpbL99yvQ34K4hRsZZjwsSdD0CAEhWQ5Rm9T3WYTdbe9Fxd7k6voROrM/SjfV7QNHjQlxa80R2oaxd5dU4d8Juynu5lOTG7AY0sWbcag3pCVKWZl2TiPyLGk5l6F5EiQElUxnjqNLzuxg+6PdtrrFF+9MbjB5Lp8+YrissNizT3EXX/caeFfe6axedbU8BrhEHXVFc8dz1U2wnABP5LxYMvT4hQtFrvHErQLQb1WVQkMYNeNRU5MaRrr8Gbb/TYNvjA+TaPx9rpj9NJpq8bkacD+pvAGjQYWz/ju/g9A/okH+/510OP/gl803slxrYVTV1+YFrG86pAf0AXpIrdOm5gnJjJ21LPNAoKML3r/RMrSoEV0pDvbvVq5Nh11HaPsr0lbPlz03N5N937x7+aGWfc+s7B6cs3D781bfPbBxVsfWTb/ga2uu/657uk39J5u62ftee6Peyv7Duw1NL1TzWt1D3646MgzDyzd/uTqNXWYLvsRnkmIi9JwFpWGdzhxFpXeImKyJERFgWiExV6cU5JdgiSToOd2abT4Xjs5ghFE9n4RvARCIHl5/40vXwNPJWTAJdeW7Q2UVr7nAl1OdXYNPgHYXi+WLqu1vbh1Ra79NU8SwuIwzOB7kf0RXNHYiFkZGcoeUVBfFIKphTNC8+glaEyJDeAiZ26eITEUfKt927TGYTchS/gcGwy/zY2ED8NX3nvtgcdhRkOvBUVlwNIK3gOB5KNHv4ZrXnv6r48/AP9HPGHEG7QCdmrAbsBcYY1TxPn31sBuWcWvkG/WkOJs5JwxjrOxvx5Ku9KMg2nNV5Ys1YPr+qVLli7RQ51+iQtMBCvRC62scCV67edbP/juuw9ajp39/nucabGKxPJwPFWq/o7wNsav/i4VXW99bjdsYpkR945elDBqMy489+Xh8KIVQVJnXcqw2IAoYqG5daIOeS4GM0dj3iZlr6q7t1w5/4FL9XgBshJAfZPHOmYoeOQx+CqY9V8I3+GzW9fPa5wIwnfD2eEPwRpI9vNvwtVO0ZxjzvOkpyYnAY3BYxc9xqBBIxpAZD9KCs/myccqijxeIBU1xUqD03q03E3gxcTkm3slZyX4S1fu6gzY5Fv7kg+r6rq8mJSef4FPGzdthO6oqWZ76zLyx8Kd7BLd6mD4fhoHKCa61ItjIXrOKYhuu9MYlHSqEWilmqHS0XQ5dy62HBz2kJ27VPXgOh/eU+BEqkfgw4vmL9+4hx3dugEXIrtwIYwrAjACqU6F6ZwYsBiRrRLE06dVxo59GB/Xjc0r9Ti8Tnoj9p/ybp4/cenOvf7pJpD5OVwJ1q37d23mX8vhL41wjVS1ajOSp0JE2074/rXMLDHTihrGe1kexo4DWgy+60xmkKKIUsbyLWugUiJcWbzb5tNqebfLR0RMI0W32Fmw59HmkwdWroRN3IZP4Vh2nGU/DIDe05C4vTXitmnDbnKBsbuPZTisj21asDrBffSo9b/w5xCf8u0BLHc3N6SO71VUFie7ZyL6jO+LICe87AZc6lfweKJzcahV7JNsq6jahnj7m63nbW93H2NJdSbk9Ov+0OobOFMn/PGYITx/VKvZ/SxbSDIl5Wq1FiYB31yvd4tmvTHIW3GRXalGLL2XCJ9AyIgUhyXnDHzI6Kr/+Txo+vr9mlqDCzBL1wHTVdRipy+uh09FysI+uZWUhaU5LNJNhmhVQHrObnaJNhwTSBK10XqOVgYglM4jJ2JiLmX002Klr0ybMWfhhPM/Rd3LuGvLxFWb65HGS5lUeifX7nJG9vFNq16RqrQfJrGRVJxHphMSYsIikrVQ7PDj8pFxlqBbP/7hh4/ZKXB1/zt61/xzw7y77543fxkN+4eBO5RgEPfe/tC5paFjB/c+99zeg8cYSVN1I/kNpE+qqszRfVJd5Y7VVtxBOFalr86EQrBYUliA0ZCIPM7dQO06dAK5ZCRyZ56fcDanxKedUmTLxq6Ec0BRv0VP7L4XHD/e5AKHQGBURWj543Dz5cvsxvAieAvS4ePgUH4ikiZ64jUH2TfkxKsgarRBeuwVec1KvTxq+QMnPu/K+Tl83tXptOXZewLkLArgey+8GRzyNHnAIXiz99S334Zrv/0WDgX1ncF1cL0zqIdVnaEO6jrDKu4EuLlbmO0GboZ/7cbCbpiC5QiXanJnRE7Am25JA3YLb0hyi0nWoE0gmlMbUZsViHcBp9KbTqRBnGrdyY0DO/dkT+xPdOWah0uDQHMZVu3OmXwT+Zd1O8tnX4eT2dNgz5RRSGku2gw/Zj1hH/zj1JHo4z3bgSn8C9lrG8oPRhTC58wceiZo4YUgdZ+NiuakayimC/GbEWkkv9kJfrLC2Sfetx63vn8CzrYiYvylK7jCOsLfw7e6a4pvvNsd9CafTF3heNwbmu1eaLZ92O62WBiPB3WHrBYxOVK0Ezt4cSKayh/KnbHT7l5Bw5n4R9Oq5bPn2HX2oBLMnDQXXIGmuZPGjsSf9z6398UX92IPYZWc58wGSIaf5lOye4UmOFLtapWc50xhNGfeoF4EBorkikyNaUl7hmFsAT3HArcChytEauRKv+xI2iOtJ+FxqHokMKRHqfInS3vEQJEeMdRQVUtaj9xjkk7do5LLzQ5W9RhdGYzMBYGpVGOV6VFhNVLZfyijMLQifZpR1Q6xQwlMHwpDc+LT9VG3chTTPF+2H4Vpd58ItuUW8nci+fDgSAO2XISg26DlAM8zeBW3VkcyJRztrBen4prlqayY0C+ZyU0OzzH4lsqQmQv/1vnWPvAm8Ki/IuUyXIRtvQWSza9lrMgnRH6Gx8bwJuK861SmdHnEe8+RvXhVrRm2CqaAL8GX6KcF/gh/BB585VLF+PGKM39E9uLBqvEV+N6lCiwVB6TqEgYkFU4NL2LtyokCH9ThpcUkmS80muSza0pycILIATADX+jXBPoc5fkFJxa3dDuKqbgCtTWU+HOpaF00C6LBrAk6AI5b04ak6jX+kmympFi5otDuYjRosTgIhoFB/4e6Nw+MqsgWxm9V3d6y9po9IZ3O0pCwJYQY1jbsEBbZjICACJi+IEJAWVWEsEUWRYgMIIOAgMggKqJGjAiKeQwyChn0+RjGlXGUQccVk76Vr07de7tvZ0Hn/X7fHx/hdjq3qk6dOnXqnFPbOd/fdrRv1QD6KDpJv6X/xNM/OY7WX/hx8oh1dy+iYz+i819J4zU9yDl2t+AVMnzOhBSXFOPJiBWFxBQD9+EdHXRnoC3St+a3QznGHppMihjPeWVQYu8/3L/90Md16QlfX7jvntLnSqsmfb/1VP2+yideot84k+LetGUvm7toxYr0J++9/a7S0nXlU575w/I3PK6kN7bXQghnYXDQr04q97IgCSQy0hQVVWESlbM/nZU7ao4i8KUEbMQvqA0m754/gD48u3r1WdSHkMbAi2RXYNpRegr10c6zDWRQU2B/MSY+SnLGi/GiAOfrRF2blaNFQS/SBYroYtN0k8fBtCNRWyzi0Ze/v7Ri0bon6KU19891YiqfdfZc0PPKZRpw/s+79y3d8ShKL8Ff1NC9CbbrV79oUOML9zJsZtKaz/pSY5KkCCZGTWYJGubUYaD6blBv9cSLre2OWLH0HQ2gp9ABp7wadmZqzn5/5f6HVz24fD0c6zN0QU+ig67aZPnz+xZfvfBF4NUdG5aueqySXlNP467QPGYQwYAlA8MgSh2h4A2Un+RG6E10QP7ovGinCeJ5eg5937BAN94ShSyhq5DpizM6HSYxKU9KEqLTJcaxQrauLbnB3fjQHFu3/qCPZOEI2+r4h/zMH1Y/9s+L9V9tWrVtn/yPOYsWzbl38eJ7H9mw4RH2OD88venVdrFpex587o03nlu2p11s+iubTn9Ipt0zsXzu3PKJ98jjGZutXr1o7jJO+waOs0r7eJOTWZsmvjtkqAgO1NBJrvicTJvHqDrYLcgXbC6rQBRGAOxuOPESheY//P07JNK7hy2vol8tWrHOWJuMUxWC089pYxcq0dvxC49VIieQP1xawU2hNJ/dGeGIFAUxWhJt3Hhy6E8xaIKKR9FIR2yekIPiNFElx8SiT27dDWePUUwkzekXFFX4/Yem4sGnGk/ghHkT5df/2NSEzE3XyBK8AJvwakEI1LM34xk6k/Bs9mYNe3OFvend1EQm4AfZm7Xszd/Ym1FN35CReD57wyZsgYvsDdOWZBqW2JsqtdQoBlnCU9ibR9U8/dmbubzUevXNNFZqJS+1QS0FeWbhCvZmY7DUd6wUvNnE3lz4fxVnkkCWwJ4M4AwYkwwyybCR/b2G/92b/T2Bp/Mbn2gUyz+S/833T5CPpU+D/RHAlacnEon//Sj/uz/7ey7Pv57/PY3l5/tQgKWaPsvwR/b3RvXvNDX/Jti90/D733hgK9l4+PDGDc89t6Hn4ME9ew8eTBJe2rL5+cNbt7y0d+KQwePHDx4CJzm0FjONyHSxmdmNBPlFphMNRqydGi7gN4xtpsIikN5o/Lu1tTv3kowNqG/BrkLq3sCgqHRiI5bNLZBNkAw2f6RBiiTBuQUqzAQlGNRCJqYD0XjUfubQUSV5q0fev+FHFEMynipfdmenKrfn3jt2roxeD/ipFBcyYU6R1i46yiRIUSbwhGeP9kOUF6Kteyk3ppAxGEtBVX66SjU5hjvcOie3fbvbClY/7Iu4a/zcu0a48uf1XbpqdL9hE/9AElFM9GZjbN9uC0yehK6pW60xg/p1GxaTEFna587pgJPa64pnocgoSTBHSkQ0mlU/SvnFihUPGq9A0XguTyHy4eH7ilbtHDBgJ1kvov+hf0IL6Pr1kqS0kvMNxAL2uaJJhFGQIox+J5vYO/0xNikGhzbCi5U+L3DyJqqazqTZRRMefvTN0nFTb+m03II+oJ8YOnWZt2wjSZw5KX9gvxT0wPrymDvHlc9nnKVypuDk+/4OlyAluvyxiVKkOdYPSo6oa3oaj4FGYPNMl065QfUuJ75r7dbPG817N5tjJ5VMuWfDmunTy0ni8gdcbx6zbBAnTevQadodM+auGDF0+DBoqToClNtDIhb8oM+U5kHLHIxUNjfBHde+shO7j5IM9PedKEeuFog2VmDNQ8iBtYF0QcpM99uNCZlSSoI/KkWKUnlBWadRRkaRXoupSkxB3KE14PYVj0t33XHX2iVL17Jf0uMr+/UrKRk7dgxJvKus3+jIyNLeQ0aNGtK7NDJydL+yu9Djvr59ffTLsbfdNpbTMU1PRzaAzMhvcJmBnDGJUgzRlkhy1dUKnaKCI15BdNDmEA1XrNvyeWF5+XSStsFwxxSFgoyiJ15EU4YPGzEULKTJKF+cJMLMO+ZlhAXYPVCUoSMHxddMInsmofy1eNsK0GKjm5rEcj7GY4QMoafP40yS3E6/NdYtRUXGREdGG2PtFWFj3xoc+4qHKu3ktkMnB1g9rQ3q0Vw80GmAAjU3H+BBoUGNgF2guPmIZ9gye2eSim2q0NeXZYt3SY6keCk2OUnDN/n34JufW9wS4/BBqUdWrg8N0BCecoDjeSR8xBJhMscS5JJXKBIG+Drkde0sdezWVWpf2E3KykkotFc0l1ZOJq5cCTYNVUViKXv4Cq6/S3a10grU4ybijP7YvHE3lW80nrd3e3h7DYyHromL1V7JFjoJ3aHNuclSTq7f5S7IkToX+GM7B9nJ8Zvdo43SZv1Dfueg1XfcL22N3xbclv2bA5q1tJS3VOlZH5vfjBLG+AoGFEq3DvB37jn8VmnIcH/7IZI3JzsrJyuhveN3drOtWbt/V1+T/4AiKPsmTHDjpnS6OUNE/07SaZRbz3ezC4XewgBhuK9Ljw5S9x7+zC4l3aU+Jf60PlJqSnJSSlJMmqMiWmyh6Kw6RdeSZm3qvf+EddD41nQk/ezmJGqmQWns76bKZJUqcGLBI+QKBUJvX5Y3Qcr0+u1pXTKlvC7+qDwpMsJijjAbohwVBJu4UlRI0QoVVB35H7W5vaJP6Tc3HzCqtv3dwwWht5uu4WvIydoW9TIEzOYTIm0OqS3WqPGwnVoEbFZuMy3FZwXKJGnES3CRQNDCH6PNo75axBJflEeABczhhyKlRtklRiLGNUZTaxYwaa1aLdA5sWp/Bi4HMcEcE6WGWLBJYqKkmCD8zs3g85MdGlwaYJiGgDb24jg3NQndWY8vQU6cg7fRCtYI9hs8xDCrfpsQbJOB2TSsRtamCOIXIyTRUYGswTYRJSZUsN6fje9HTNaiuteR84F8mqlrw9t0Y7ANsL8Z5Ye+iPELISrlqwcIGEziKHDgMpUyucaTEeItGpEaxgNsNgeH89BxTArGM57N9sU7icEuxqYJ/oQ0KcFRERlrlqJiQzKOR31Ghd2KQotNmYpFYHS5whry47490ydNPu6rGojIk6c/vLI81KqpZ8pnrBs2ZvKITXcveuHpv20ac/9oXSMZTttpJb9TAOMox5eQHpUqxSYl2OIMTrfApkVO3mi1xfk2ZTlM324Hj9LZvbCwgCOmbYmJeLxKi2RA6O19e2ZM5BhSWUeY0hd3X9nIUGJYTq9SsWQztrdxPr7G5rQm6Fs8kHF2F7SLLCfXWU9EvGRm5qCgMhFg0F1ztYjLRq8eNWr1aP6Jdmnf4BOsuzkIi33EbXxVzYGiYnBkBDEbRAvTrYLfuJrPMjjJcxxZRQbGLFnxBoeJoAX7Zbp3KCpN+igJlQ6le+X9nyG8HonTz21BEq3ecm46DaxHxYxHj7PZcQPjwRz8FP2ecaUJPwWXohmVF6kresnMzi7ypSbBtmKKg8Sa2kVKdmM7wn6EGAuuSAieSlLu9ymxtwv4vm9BG/7lwcM/ePOnzTzJh7zxd1T97Ld0Gq/5zQf6TDemi6XG97n04HFOtGOY08lXxvSjRyFPeVOJONU4lOWJPAabT2uFvnAhAxWgcpJZH7hcazLfuBGWL+plnk+VYCwjWR+4XE8y1ZwooukWctU4Vokgb4uVTDa/ySKZqoJnCJT7vTrf+eQ4fZ3+Idw7vrMO/R29HPJ+v4c+dAzwPcug79egKzHjIEp8EHp8ESxtWQVwTqJUdJbBRIg2MZhd0EA0k26nNXXH0Ao0GZWhZcdoDr2NDqNuhrnQ1IF8YZzAtLLH58zKjoyQIiNdQmfJJfhdKZKrqtkJFj5a+EWNQsUNijJ+Q7urIRMldDWH9Nj7Er5tdvuce0fjl/b2HOFO8NyaMmiY8X6//37jsEEpt3oS3CMunX5+7L6yW/om7srwdZq0e+yzr0RaDhkME0bfvuv2u+/FGXjelIm7xky82ygeskQCVc4zzF/UMLdZc/Ok3Fy3YJLcgt/NZjEtMQ8tfocWMZuvgPO7N64Mo9oUtKjHyNawHQktGjM7p/3s2/BLlxiiovHuiWN2TZwyjyF6790M5dETDAaG6CvPjt09qZMvY1di31vK9o19/jTMdBcwzK8apyneiQSDBLwlSmhdkFu0k5sLcAUdjw5dMt1S29C/lnNCB9IrWFKJ8i5KhmDJ+ELuZcN2Fu2i03DFpVrDidobdUCtv7Gpyd+4rREHHpGwQQydzFUOKSK4J+hC+Hv5G+z6Bj7wG3b8htzPLvcDCBcZhIsaBCNiEIjJrvoEsymHTBQIF8Gx2zfwEQLA5Mp0XC6WkgxsJF5+gjj4N36Bn1wYyP6WSEZwtK1URhuMXXCLUV7Ddzy8LNfa1nN5xak8F4Ot5mKwj3HY05tGiaX8/LYy4s3KiFfEwlEmFQAfeTTkwSaSKwiNXzAJvpOWklKBMgn+BntTwfLU0lIxm9kmOezNx40VTDa+0ZTBU+rwx9zfbQ4+0ZTBpeYJ4WPezlqWks1T3oA3ShnACu3HH5Px/Cx51Mtsoo6tSlsQYrbOfhSzpxp/zA0HhHaynKWt5HS4WVo1SqLfq1kZ1utZ3l4s7yD8hviRIJxkUxU47ygMFXuRj/juWgdfIrIYY6INEdgcaY6MIqJkjuX+APyEycvc/AK4Y8O5Iov1qcvgMhjU32IvmoC+ovUoT76hfRuKlm9Ey69+ZP/oavAbq3EBq3G6WqPXlxDFGNUUG4FJZIzRbIDDvmbGvdEGvjgR3KPKKoQfxkTqb7wM5bE6vgpYld9DeTV0+Ua6XPsG/XtNGEr287pSfFZkNGA4jcvbw1gKmpQb1hqyXx6Ia2gHdEnB/fJn9s9AijMob2tQTJgYRUNojOmgaDhGoEu0A64ZCsUvAyaM+kkkilTz3n676Rbe228L53hvf0ai8Fm1D4EHtT5kOhr97PzKyZKXy8tZXwXKcTnZxnncJFhfEVjtyLBS0agKp8MJj0Uk/cb7rAzjeBgZ5JdXdaXAA0o0slgMgpmfsOajRI30EgKhgvkxnUShoSRdAcWAoV9eFeaSk4YEwcHPa9gki9Vvd1jMyhqWxSxZVqonrNS4c0WFfQg/8VTYieQw0hgPXFzS1/HT7Igtzn7LPthDauZ+N2hcng3lncjDMbnjh3wnf72E0SRQTs+SKC1OhcEkGVZVwFGllUHbVA19ivs3ZBou17Hcu2rI7htmXvb/O45L+9obUgxfaDheHTqhU3MccZAWJmb3dPKlGhISJdGW4BdYFchq8ScDoyQZIf4przC+ODcYGruoEMEP4+ZmVcPhGFJzo56T6cYVU0aQTGiSHU2AquWvvus/tpNDQafD7Qo6Squ3MWwssM5pNEjE6LcwgWDxm8xBykF7ocVZEIaO1e5CZFtgXmAKeYo8IT+Aq+Zi4SAWvqP77XSf1sJtvIU2aCGJiZbESDZFsJklU4TNj4zWWAM2gmnQooV8RLEfg76qgaQGqgmcC6xs+MCQSx5RKk1YguOUSr9DP59AP6sIsDbhTPIVuaCcX7ULUpzdb4iWDJaIOG7nWNULSeqcrhNm81bgXaay0zC/RFsAk7r3ey5ctLDnzMaPyYKSC8XzK+YXd+l2djPO7DWq16S0mm0lZSV33Z4/8Lk3YIT56Fl8gvEdEYohJl77DvyeaqJYICWK/sR0KbGqAqaeq/S3zPj6OuPFrP+VDYR+rAtkXPhKM4O+unDnY+6EvvPzFz2kGBYPLcqf3zeh24P0rOnGDfPUz84NWDNYNYaGVQ5450NuDC2ZM2jFINUYGrqi/8KVijFEAiXMLtjGbCGIAjdGKPMVDB04sEeXgoIeRdKQQYN6opKSnn2kUQmJI8WePdhP93597RX53a0V5lipvdnfPkNqXxU6PMetdi6PFYEREhwFDrdTO23+e4yp1sJ4aeG7WNeBndU9Tf4Xemlv22YWwiNbmQygrvApd8SeNPkty+gZmV7/bai8YEa350/f1Bor8ndvO+aWtzh1WkJPxh/ybMYfGzl/RMJNEtEigRQ1g6UVxhcqR2j22pm6hitklLwEr1a6cY4p5WhDfzbnIIG+vIemgb9SIUcY5st1xMbmREkZcTkoLS2L2avxWTnsJ7pdsr3CFm2tIEYpgkgRpqCZHz6fgv7QPGQ5FJuPP60RPBQj7U55IzpEx+MK9PdWaCr/Gb2YRrvgaepESz4F5qN8qm2CsZH0Ee7CtE6Ztr4QJfBQVEZ/dEiG6yb5WUzjyLO1ef0esRR30abx3bnlJu9uuoanIifTn9vAWRjTn9uaFoAd9euPTdfQJCXlRheWAjlGKTnoXHAR9Ms1NIdsE1P46kmy4hlWjLNKEXFxKDVFSkWgdSsBLet59TYaLE2wftNh6NZ9N7A0GmVY/+NXKsb4be0LM8bItJoaej5sHYn9PsWaQW54hUsMk2Owl8Xw6OxLMSc5pZikJEEkEmZ2EEPEBBupSMJrQhJbw0kTqllt4EW2NW4UKwL7yKSfMrUVrIPql0uo6iyqukx/ttOfZzdHjtF3EZvdZxt2c+od49T7Y5MVLOPARzrqwf0pa4QoRSDQa80Ix/qUNKOagVvSgV/rta79ngTC6cPoovWueAurfbvau9v1vaukqL27Xe3d7bx3jb9cE3Yz/K7x9T7o3VyhCM5nZ+flS+kpeX7o4UTBHiUZE+1+iJBdqd09YEirZ4Jv0s/AB4Y20m8sb63/Gxa0xhnk7eZEBzJE1dS04BTGsYGPgm2K5ZyS5Yt3JklWpx/IHm0U+Ehi40lpC5C/+YhqDffQCNsoTm3cLU4N9ksIuyoFq/0hbAjH5hTHBnAp9GXExtgdDJ8oJyDhiJbsDonhZDP6mbllt0r2NZoc1O2y65f0NPOnVdxqSLfAOXHyr4da4CbbL6MIO4q4TB84S316DD8J0gsw7OpLZ+jEMnRipRirpGDqYORySDY7XD7Qja2WsgipoywMuwUqMoarjXvEyYFzpNuvl1vBTzfI6HXd6FpLS/EizsU7Gn8GrsU71gelmrKmpvL9Uwrf36hjKWuVlF9EzvdPNU7nJbftBCtXbNpJAobvuJXrijYZJRtmsxosWYkpysSsPs4ZBdbz2slpg4PpAf4UgJNm/siBr+U04nsq4BF7fnP2G/xD4PmnyPXGY19PRxdqUI8aVE/zauiZGn5G+pexao3JcOIgMtofEcnUkFIpYfWbuGA/w5jxjBozstBdpD5KnSb1IY3ntjdcN9w3ryHd2Hver6NNkTvO7hAvNrw/z/B0A55nvO/Xbtuno/yaT9gP6kbP8S/0PKNK4DKnCkipPwZ8GjVafb+dvy9hUm228r5xvyrVxoNOCMSxlG18tTpVcAsdGVe77QbiFM1ewZ/hlTIcFeluKT01NUFKtYatXfdVRtvNF7BR9+5F6g1vPRfNab6UjfbEZ5hIZcBIGhp63WxZGx1pPzO3hqaz0Tk+xFeNAYRFUdzG2re3cSNv994zrN2/lMJ7w9tCNvwNqT9f4a3f2zgB5UE5poeuMz0ULEc67hLgfVOJmG0cqoN34AyMr/KmW8gF41jBK+Tx+KIdPelSvMcfnyjFV1V0yc21OKxWS5TUtUMHcw5CZoNkMVvMItgrgmhX6GZvPboov3HSWuRXu1CgWxZlX4hishi6FTHuzaZ7WovgOqcPKqW6hdMuAfpyXzo2jS7mtguJNtM/pqHlllYisMagjNDqKspAMYo5c2TiGLrtDqDBWHVFNGhL9+wmJfX0J7mlpKqKEQMGmEt4y4cPHKhSY3CH3DEiEMISTom27OibEOP3zSWUPYtClU75wIPEzaZFdGMrtMLDUZtrrj2ZeS0vDFItN3PGaIv8TBpeKt7m97akXXd/0U1XZU8/321GgULOh1KLvXRbYc8Ehas6kFNB23ekr1NykhSX7IcbVesqPDl+j4UZw4yQmenp5jSMfy9b5d6EkKH776r9a3O3zkn7lCVWeSNN1+iAqtEHdHjL5uM+sAqL+4TsXyZ5ylkDMV/veabxO8VeEeKEY5DCJA/mkl1JMeKn4hRqXCOnmETKF7oLJcJU3y0pnqwk0ds73V/UWypyVMR7pXhbRcfu3S25DoUunQoKzF1/P12CtOGiqzXyaEe1QIR5QqKNzar5rIFTTCfPWqXcS5H//HPdZb4pJk2d/wi9H9JUCoqpmoxrQcTjZw7vvPqYslvm3zRo+ANzKvm0AkgaqAjqepWy28Io+wxfURODKclBjmqfEhfn8VhSVYJlxcczVspMSvo9RAsnHPdOcZM4yFzWA31gbtAaXZQ/0Ah8o6GAEwO/gm+0pIMymSILjh6lu9hU6xrsTGHGG6PISdYy0FX9fJmu9PQIp9XKNHBCu3amRISY/o0wRZh4a5JFwc8blFvQBhv8RkRn3g66pc34zeK9DZE3j9Z8lMdmZn3VhekTkeuTA411mn5ivM7ek+18B83EZ9I2MCaMRpNkrOQT6bVBu1bZVkOgTdkT6MI34vCRCWRjY/4EcQHfaBPTFaNVEAy/LGeQtwUhxyqrgLHMQI2JsPtNrBpjhL6K4IKVVktBoVIT/P5leai2XaL150pWIfsdrFOple8/8BZdZ/VGwl1XgiMi2dwoEknQrjUVosVkkExrdTM6bhPzZUDkgWV9Vxd8IjBGfqee1bhNnHyJG7rzG5HJTA/TbmeBltNYDedUWjZwvj/QNBtsxV8+ZimHlZSmUm4rHvilQsnROAfWmHl08G3GT5QzlGRVhRFmbiqPQBQU7rHD9curhvV1hvVHjxo/+TX9KF9LhXJ8f0RZm7arO52MOIFyUxdlhwS9TaxwlkDZ0SaZ7I16QgIzO1eAE1K76UlxjvEck4BJfGx2YPZWamRUTqJbSktMFFJRgmQgCFd4hQzJNdWh7BODp4fc85yJYS9AjTfCMI3TOziAuyHg4SmrW46tu4F/yWbfuu9G06peefeFvReufnK+W9X27aj74cP0LPu9feOKRzYZ1iMffSP21V0rdtiiSM2BmnP0JPKJ5+nDpzdk0a1Z/6Kdr85eYqCd0WLYJZnK8H+Q4Z8gpAm5vvjo2FhjCniUNxlJhRUlS/HNYstoXsqRLZPZL1kcZ6a7c2z5/JKgyQZROo0YL5GvogSEq1a903nLmM0REY9v6HTwVZqP+lcfYfgU3Iq3oN7ogXYon140Thr1xDJrY22voyWY1ot2WjRGzMmgP8CtU/qiOMRQISQK6YBdjNVqSpOiIyLMJrhJmSolMOwiW8UuGxd2sxeF0OvO7QiGnjMu3mY04tGXr//rb1Wr3sjdO+SRIY8NSBi2azhdu3R+xTL6IuqTgBJ+/BYlx6E+9O3IuVOWLkyWi1BMZE1sNKZnyOytx1PwG66jjHem0uOMeseELGZnFwjDfV7s8aSjjAzBnc5sx/R4Kd1S4YyL6xqVLTlstiirxRJrnmriZ3Pzk87lB6UXv6DMPqzv5QclGcpxZEMEH0e8idE23hFPeEuIdhvTQ1iGHMSs7Lh4RzZyxjuMRrRu7eB//vuTbmvzYmKLu+Wv7bawcEtS5ktWK4QuPBkbW7S2cHAflOBOf+GWISeyaJf+j02fS48noG0voBdQNrq3AGUnBEwoOYF+3HnCEzlpASOCMINnE1BeVKL4X2LA3t4pZlvkrz9YSfJ7fQ+x84SVYrn4DfgfF3r4PPHJTmy0WqLNkYlsnhmXKPhTEqWMFH9khmSKjTVHxvgjhc5qe3P5b2XXrSinCM6j5BTFgyeLongT6Op4Uw5ckS/SHeU/seCV0mHHHz5+14NLprz88IvDR7y04M0pSx+868qkuXMnsWdl5ckZj22aWbvs/a6dzy97febmzTPfqPyoc9cN86dMmQ8PjPhHGM9nMZ5PZzh3ZFhne+LsCVJeqre92ZKUmOGOyopCLrtNirWTig7IJLUDAWHR7uvm5xZwE5cHY+erwvG2HOUGfIjdwGclGwiE8RrDGjH+K+yG06+/kHTPqUnDH9/x9stV814et/7huYW79tF1O2x7hyLc7mk2MPLQ8LN5XQl6z1NSU3XwXQfqQi+Yx43dWOGgxYlDazbTlzrR98T9ZrQifeeA2+nOGPqgZ9vDKidWGC7DqXnWqiJfRnaO5Mz2OyMqbJFRkj0y0hgrVBjdiqeXFClO5+lFWYRT9uFDcSJg76aAh1AzhXt9gZUwbFQ9v9DtaGa9JNXaE3TeX9aTaSEHMGjykdmzjzT2CfcB03iDCVgkjFTjdbaH0zXxlgRTGmpnQu0t7CcqJ0PKsVRYoxxSrDJgFK/tMMMoLtbt7BUA4zBl310oCPMmzwgfH4zp6UknIxdivLDSi2yXH6vvetC7dPCiA+noEk1CBH1BOw9BBWtXdNp/jCaNQt9UeXM9GVUNKHZ++cPDxx3ZW5Wa1jWvir7GxgJqgt3XPswoKzL8kUn8jr7kKHOMFGkmFYkpbMotMRvfiSSnEOcXuE4p5sucxYoudtuC591D7lpgX1L9wabIv/7z6vsL1hev6n2/f/6yebgLXYcc9F9oIc794v1LXw8t2XTnmqUVy8U1Nbtr9vDzASOoR5zDaAhefeJio+xSgsUouSwWIQbIFvQSAD6cC9QNVcW7OPSw1Z3PSZZu486SnUxElkXMfmA2XPJEP1dIcX2ndqRfoBfpiKlnd1PPiVjbzr3YXHUIZztfNTMz+VgVTXjj60UOhkea6rXLBmt6SuTIKIskRkngucuqc3UVvFWq8znOf3avWEEOyym4i/w+k7yn/lElJtfSlNrXq/4hcA4/KT7ENW2KkCF09iUlutIkW4Zks8Qhl6UiKdoSK0WZpxotinQFjcDqes9ezP0EKPpKN0LdNmNQWyEbm2ba8Fz5O+QMVK09m7/1jmo00/vWg7QX6lG9D73dZWwmG5z5PfEO1AstVLXWyC2PRMl/l6dF54pcbeUNE72Z9Ed6J90ZZUb87NpAxt8Sn/n09LVLNCSJqWkCbLHnGtjosOdmSrmWihh7JJc0eg4HT2rFqocrvnsNa03Nd5u4ZzeV08MnykWFA5FUJ5/H73jn3TPs2VHrJ99YVfc/W3+m6+twL/nWgauXTPl0btLk7x+68uPIkei9LYe39Bo0eebgWzeOv3PDI8vucrIXPQeOKsvvdDar/aMPF1UkOdWYBEdZ/yYxOzAuzpQoOUQkWU2CKApRrK9doSNwbIAWKKf4lVihIV9W4JjPg7gbq92qI6uVy9AUWoM6fE//4Xt8FO5ahT/QnFn9ha5ZVyX/Bad68kzgw0r1g2dMZ1K7qy8pKzkmXfKkpCQkCLaIqQ5LDKnI07MZaFgwsGzqObxCdw6zCpSYeKBleGg8mA5ac8C7uifDxH4ZbXAeyu0aj3LQugM1h2d7shMTZh86XrdtdkJitmf2rkUfb0YTapLaIes3KAKN6bGjUsQrNufRry8fPowsE+XvcCExMwYOLKOHDtH1NQzrexnWExkXdBCKfWkuW4KUGpUW6TFmRhoNUexHcNoIsw91mDeTcsrNaWbBMGJ2K4RhE75mwgePEz6NIPkqCwfa973yyitX3gZB12H5sNvvRWvYPHUNnWEfVIi/qxm2fmCVxVJedeDUBSbgho66t3x/VbnFUjVo/VAuURZxv3LrmX5kowzuWBvZQCZR6dFWCUdHRZsSUywVyqWofFsoZrtyVKOo0FQIoyzLZXDB44zTs2bhojr2D12hGfBkTJvap2rS2IqPHnp1H+PCjOMZWzLQm/Tu0VtGH2fPwrFSfkHx/oF96i5PCfO3mOqLiSZWyUiIiCNiYwWz0Jdh0LdYi4FhBbNUBNuZ96zRZitF71ahdy/8VPUTTsGds1Ey/TJb/kD+AqeguR0CQ8nxDvQx+QuQMhqXO/ieS09fWqTJFBdHYpKT7XaCpUTBZSFEsFgYx1uDHA/OAYrtxeFzapX3UYF20Rt5bA6PEsJsy5YtAWR49yT7RRvfdTo3oRnOTfiRKvyI/DA8Vcov8RZ6kQ5BHXV42fi6bkdfYqpVisLOFMlCnKnsRzA4wmL1Bo+hajEmbO58MZ7hYRQ9gIdL8yPlYiMR7fkJJcSOHp9Iv/n6448/xm7nwUfXHXTJn5AxVej5T89XvXOJDhbP/3vBg/LB+dLfGCpBfFLYvN3LxmNPn7tjstQxHmfnSU7SLluKNrWzGrOy2rUTLGmSRXdLuzPrpwIVt/z888EYGDocQbiFoerolsO4uzvKV/AFjP+MTF1n3YbImHndaOAdhjX6etzjonwFewg99sY46sSfVM2qQh13Pl7ldGWkV236AzThvvvo2fTUWXH0Z0lSoxLB+d44iC/iYwaIZMGJbLJuM04lLruEBVdoUDJpAmvkquJS0AW37ILbwwegQwuioyLI7ArGZlT+GB2mYxl+u44cebpqQy2Ja/zyOm3YUPW0eF4+uK1qyx7Wu6O4byslTn2B0MuX3S7f3SWzozEhO1fKNlUksJlOZIUpwhbNw/pYJV0o16CLPM3xFQ/sYzU5PCTDo3CcEteLGdL8ig3Yqorah9sQcfEs86gvnn5u64bTc80WADNq9Gj09f3jEio7TV07sBSZ7xwe1z9z9kDfFsP6T87TT2bLR3CK/IV4Rb62ZnHlY40xzreTJpVsHb59NMpwvhoz3TNz6LOrKfgZ26daBKAxEhPMFfHMjjYiv8tkZAapyR8LYdJxyNlLbrFyrFENxuPhB7ZcccAQ2MTUxj40+57lVvkpPNV7jm4hu+n1BzMX3+f4Fd36Hf07TqmdfHvVy7W1zviqKvrTCPksToH5Lffyyv2BxyqRrWMkg9kiRU2FKFlmhYTKdDzk3dOtxoNDS3ejNbWN3+Evd9PFJEreRZY0XhYzAz/iaYHVOrmeBjECYyPtUpzBKCUaDEJMJKlA4DFL452Q7aXJcVuYBLcFZfeQEaaXm0nuhaZRQ5jULq+dUYV6B0U2fbtqxsmZNcE28nN2cAouVjRXRMC2FQo657WeUfxSwQqQ6ixplGiVt9BJopU952trG/PV4HQoCC2exy8hRslKnDhesmGCzXFmZtOZwckob5dO+gP0rEJDYZYKX5X/jI5PozH0T+zhdanf/1SHxm3pcbzHlh7ortpa+lYP5Q86Em3SyZZ4db1zkC/TGhWVlGQ2E1tGhsuVlsYksSUhOiVdAA+40UzuOcNlcTG/SRiSxqpEJozwhDsmhR9lTZB4iMNUkIMKHB54jt06/+6RF/ptz6/r+od+F0bePf9W+udBowb5bZ1sTYKz92JsdnoX4QFVcMoXjaPPwe8q+XU8QH6dTN60SS5Bz9CJ6Bld3Op48KluiYwRDVIsEv0QucgRJ/jjoioiuV+Q/OBanY2vnIFZ7lZDWGuWsadwDxpNj7Dp1SwtkvUsFEMPo7H0cN2bVYerSDR3qPoD+/rmm7Bypd68wEa8R1D87pSI04xDYd8LK16dPxNLxYPqamKiLwa61SBKYIbww5NnYMuzpT/nBOUh12tq6BLlaWpqqkYHDEl4KTaKCfz0cX/qwTNNVvB47bMIRn9oGhKcfRTwycYImGzUh+YWxgu/jlDmE2izbOf+YKP4yp5FMsDhVqKt7CFbaOpiQ5tDcxXZbizXZie/boST0GiyWErWCGxYHodD5wK/YMXdtAGjQqM+QpNx+xr6OOQWahldzik0iVA2gU3E4FfOGRbw+/tZ6hlNHivpBp2NtpxEW+jsWvRcDXqW3l5Dx/ET2Mpp79bObbM6tdPdi4UTYpG4j9UH53gtkWZsICZzRIQo+I0iPymsro8gVITAYaIJ/boczaA7lqMpaMpyugPNWE6fPrEYLUFLltL1aMFSupquXozm8z5+krXl33y1OBnaE2eV4qKjJLgaxE8rnc/NPd/8jECznV1c1mPMmB49R4+RL5CvaJTyx2jy0ZgePUaP7tFjDH2MMUHn0fCyZ4/RII2mozms1hTNyzocIws7ThPiKZWfiHpehFNf0Rh8bZtJGb79D3v/JuKPgp1/c0hdcMvG4Qnu/Reoe/8bX/0M+Z5iDNjztbOvfU7ffApdkd9+Fc3h+/5zGb6w778ZaL9ZuCSO4meWWG0EG00MTROSmP5nY9UoSsbgaQ/dqnYhcm2GYA6k9lLozAZAm8qgpXFobp/zpqeeQuedxLRACallU94v9KeYuD9Y4R6xF4cWCec1MTEZ2QgVLP7mOPJT2iEcHcHj5G7XQ+BThdQG+pHXUI/LH9k/ukwPnpX/yigNZ9XvEfNV+B19KeD5SsE5IlISIvx6zIXOwRMl/PqWeqQcahDzNfwDA6ESVHYWlUFN9Da1P2sYL9QpsWcZ5iKCk+UmA4PfWaFEkXqOT1sJmA4jSR1QaEtNDSqqQXfTp2rof9XAjQVhJ4N3DeeQAkbyDMEEv+kVPsrZuCVnBRd4ZjTFSBEmv93lJ3YpgvgjVBoBdcCJMJhBEFQJwo/AydrpSByyefOQ6Wcvl27bVroI1eajsWlp+9Ly6WH41VyGEL9OhhSCqcAY+SR+r0b+EN0HnHCOdCOf8Xsj1leMYlAL50P3cMfoHnIOiSgGiZf32/eTbrhMPohepYO5XEZl4hKxE2sHnN1w+2wWp9EeJ0gZKXF+LyzNG9XrA3zupRu78doZVE9GDng/KdL2093a8imbxzDxsHXr0tsX5eUtuh2+7R837v7iEqu1pLj3sGHo/T5Dh/bhf6Kyd/c+e7psypSy08/ufff48YOzx0+YPWvi7bNm3T5x1uwJ42eDb0o2ViEiVDSMcpMA3tNN4VF1wQMQTMLA8e1a9D56//KPP+IR6GsaJ7/IfufRevlFVVtwSe+C85TmGMmsX7cKaQydwA+qjpDcD+kQ0kuT/4GPQZeARznFtzjThh3DYyDgRNWH6C2ixH20Q6zYiAgmcsygbjTrFNoTr3oPBcvwzGzRWlVPN9YZqmtrGyRDdYMEUQoYFCVKQarPClEKID4BNsOupVUd/dwGjA+LUXCa9iaV8jL0Gs3Hf6o7ih/C5bW1crVcyW/ujVcxswCVMYGrGeagkxC45QX2DOLA7CfO32tHBnSKXqZX6/AdlNmmDDke0UfxV8va24+3X/PoNQjfLb6o3phRpa8Wl57Zx/q49Dz2m2v6SeJlBnB1DcsDN3s3qv54YPW/QCjwuSHeVqcMydvJn+KVUhwVcCxxd8hVj03p0iR+zqiF7gkLYAKuHdpIQ3Ob+fNZzB1sNDT38pP0wuNPvHCk+vEX9pYNGnrHHUMHlcn388vcKZDwwhM8YUhZ2ZBBZWysprP2/CmsPX2FYUJvX3ZiQsLAHtLAbj4pKRka14k1rVuKv5ulooUPIt6ofDZAz6v7UDdpHWmrdW29n9CsfVuh1f5ZK1bMmvXII7OyO3bMzu7Uia5s9qJNKsgjquZVVFVVzKt6rGeXrj17du3Sk/Zp8Qr44g0mmH7glEn1xaAIg5mYiSHSXmHg3WlTF6v46jZhRjQIOBtq8uZ/hbbEofVX8r1iD3oeb5PLUX7jGQbPjxLF+8SRcHfZZwfNY4hgZgLIyanqvSPGIKDOuLUAF6PAJuZa7UOUKt+PH6Wf420okUE+wWqhs+MAy5NN18jPaowQNhmriEAmUWSWB2DJQCoLD0oMJQhOAN/ZyMFj6eyvOJwrdIETb6PnxR6NZ1C+4m95IMO0lGOaymAKUiRGJojbIolTmQYDNi4uPh/SiWCqG/AVuZzB+Rw/Kt+PUlEiWh+HtihVMIi3qm13CF5fXLRDkGIcUQhHikabFMHgWsSpRgAMAj6++LxyiBeAm1zuwhyu15nGdMWjH+gI9OJpPPA0OkH7n5ZrTocqUkhCF1yBr7z/GGV+4B6pvD5njMFiihWxKcqGsS3KJFowrJ/1jWed2LkzTOgUh5OoIL7A5jHx7szx2AqKGKlu46TS9atKtA4/k9KfcQf50s+BYz/Ll3iNA3mN8UK+L9lqirQYbaIlxiGKjhiLiCJxhYvfSVRManuzuuNh+tOidrerDi2hS1sisAL5a2pwXBgOX3PbWmAziKP0Nlg9szGhLR6V7agvfUtLaXpcn4Iflh/RUoQP9CnkzcCtWgq26VPEpkakpZBR+hRjn19PaSniY/oU00M3Vmgphvf1KebaX0q0FDZ30qVY6M8YUrAtPIX9rWJgeD88xfA+8tGTCjShWkspsFWrwJQUlBcqg/JC9bCUU7qUU/oUXBZKYYaLPuW6LuW6PoVUhlKYrtOliEk6rJO0FICrtQfxekI1Qa5QWgErFd4mltemx0+hkAJRSQlB1KiHbeGtCtFVrcugpIQwaUQsHev6ysRzJGIliwKgEXEwrcFhvXowCCcsHan1yAcVDhObFIqE+l7DX8WyGRaQquVoHNUMlTZbpNZjCYOlnDLSVmEEG1x2Dj2u4MP+w004d5HLhMq9dC6+4Q18Iq71No4Sj2pPIIlcDZSgcjxevoDKz+wyLPei8sAnXnyjcZRXXPvrSa941Kv/bHiRXPUGSvB4r3zhjHeXINhvgluOkCt0Zhq7SOjJtDacY2XYFhWQcIxbYt6sFQXNH9ai3d46pVFdvPJB3jJy0htIaNa8sGe0eKRxyW5o726SJkfshjbvRhvp9t1ndhkHe3fTuazt8kEv7sIJEEjwkpOcCg1rectv/vmieMTbuIQTh6R55QhOIbTRS7cDmbL+IyoNE0YKY4TbhYnCFOFu4R5hlnCfMF9YKCwVHhZWCmuER4VNwhMter7Nx8BoblLo3jqNb/a0Rv82+gQepQMyvY3HeH+QSd7AMt49eItX7s97C53z0ijeeUj00nrWk72809vos5s9vD97iUMbr/SCTu1FVgT294Ke7YVr5Dm9oHt7oe9p917Qx71QB0p7ndnVa1oPPJX1aeMxsJihiwPLvGQS73G5vxdv4QxAo7zoHOcHWu9FYp1393Rvr4ZrvKP/f/psjOMMIw71Nl5RuGaFN7BfYZ0arzxH4Z/vvbQ7ZyLUwUsp46Rp3h4guYYJr4kzxIuMj4SsFn5bdl1bufLaLv75mvYFPplMCpVLblkyPDSgDsquQ++9d+jZ8+fDoFWff1Z5zWM0CnOYdkuD1XyAmwnHvDIL8kW7y4nFHOV2arZHcWfBYL9Mv9+6FcW8/DKK2bqVfv/y2rNz555du+bPc+f+eY7+PeSrnvvnNcF0IawNcW22oSX6LXH/bVi2VkjRggz4OifCb8BCbk7ZMFjyN0rZMHg4mmH7e1rpbtlJsr1FFzHMOLfgMgbLrIOklVULgC5Ta4RctnBmek1MUrOFYZbUBmat0e3Qe3RdKyyEFragnrM16tla0A4tbEE5BozJVz1+7drikBybOy7OAYdNmqO5p4r2j3tn2KIdjua4Vr8TR/tX7UGnULZjx6LfronYgp7NDay2+LCaxlTtee8Qg4iy6ccMWnhLygCFasClmuHx2zXx45NuPsIMcKayGan2VKETDN6z59Gp5s3C0YDDCYbMTxyPsLqcrbaK1ZPD96htxhbdPIaTZphKqWb9U8YqlxOCyMB+daiuRH7ur5XeKlLOgMQh5ZhtlnpSNKzXcjIzc9iDdo0cNGikbIfP8M4z4s+MRjnNiBbes7uLvLnL7nvYbzynC+xjaDhEck9inZkWhvs2U5jWXci07SZY0QxN/ePbuJppautK5/+F97gso337DPacVH/TZPXLO+pv/A/1S+BJ9QuZpr3Z1jyPvEj9gp7W4AXUL2Jv/os9wS/as6/5i0+bv/ik+Ytnmr8IAg3juuTW+SCkm4rCaNGKnnp25tKlM9nTur6q5mns4XuaIb0F93h/U3cVtbEMdFOdtmbtvn1r4ek/enT/fmPG3FzHVSt51+6rHtNPKQAe+bqgx8hy8gnnUqGtxShctmrv3lWr9+xZXTJqVAl70GPKn6v2VvO/2aOTtXDDWihis40sHYxhbCr3g1JmL5P7jVc/1EDw8y4KvQi/9yoUKmXbpBDMp5opT+iEOWDBDWvdmGC2BD7D64hidfDZkEeDXqDAFY8O05XCZ2BWFup/zRrBZxQIhbYC5bRT90LFZ4bbaVTLD5MPPnue6eA5GhfJBz/lKhN0JsNCtbAcGh96FBpptQO++IyuZtUuYzVrdpka76FAU6Uc42rFLgNicM0LdWn6mdflUitRwbOKBD7XPKPpZyYLPYWAEfnLe4dAtJ7hUHdpWpxhAFq8MFi1Umm1UqFmEai5NDw1BBXc+Pw42NtClgUDmWFaOofPTQ/qrD4+w82yGLUczMavpMvoMjUnXYYqebg4fQkjlDCElwjL3zI3saFQfl1uYm4NtujWAw/c0AEXWubGbncQeCATIM7RigphfA+zN2irIacovnl7UeXRo0ebNfroUX6jKnh+w8Bm8w6fxWwUsLlC4DsGyiotggtBORaM/k7noU1foT/Qexag7vQsrWfccUbuIfc4jJNwknyV9wzaLh4l3/O1EYebHBKNh9B2rVeCaSYlNcvtcEOOwEn8l3FyVyVjNcoTEHvmkEq1h/lqE+teGJzN6+BrI23UADLAbXOzYldJZWBZCDyTWiH4JqUGyAm10D6w0cTrqiaVuhkNUSQSk0Jc+IRJK5MqrRgMls4mltdlO8/FjPBwy1SxWwrhOA8P9Og0erJgxw3iPbp54Lc4NGz+hg3zcRJ8yl/ilC6sF+Qv2OdrwbdX52+oLu4SShJ0ekrlBA0fh4KzglM1OqWhxVjjFO3zn1oZ7t/xva38/+n7tr6LSe3y8tqxJ3Cn+gVFN/8ir1O/kBnNM7d807J48IvYm/+6yUPr/zdvmj86i1Nbh+E9iIJ+awpDnKU9vCvx9WraB/4LbcHIKrB5kPpwGNVsDChPkBlUmIIQ0QKGfj1Iwamg0GNQn7a+N6uHDbtWv2stgH+sCbpfcFdOjwn4Trcp9ZNC5DEUekgBctkKclhN1XTQGfzwlwPPyAu//ZaDRIYz6LUvv2RNWneG9v62bVhw6bCwyOMoQIWkoFCh8MNn6KAvv5xxBp0OQsMP00H1DBw6DXUIQrQOnpFHuLYG6ZQhZAleZrMp8Is8hiIPKcoxGYpyDIUmpHwzhd4YCnIMvBVyds8H0F97PrD57rvvptd8PnzdJwfYdySzD0n38pWqAWhc1QCOGhnSs2dPeoOl+ny+5ct99P27lX/8i/Lu+QEDBoBERdtJpSI1kSpRNbmpS1NXhMOloV5ytin15B/QQrquNanXUj62ndMYzKmyezBba7lQK+K2TUmIgrVDk07Bp57/w2Uo9GmwpDIC1apovUIUrSxjWEaYm5RV64VSsFHSrDSHdtO6dXjD1ooec/gO2zK/rzzgGt5ygAgOKqEPqpEoJolrld5yqKWrYfuF2xEiqNBqZsUhXU6ej+VRUgHKp2gk+YvYOxzKp5q6QSNVLcSghHLyfCyPkqrYd1fFo+JnoNELERiYZVdJICDCXQNm7yxgehtDC9EiEpgDprxS5hArsx9SGF8oGyKHSICl9GJlblHKZCEk3hIQWTEAyq0trSYDryvLzasLjMf76BFeaTXuwz07a/UaoGYLYVUHtuM+8imOAD2CRqPRHJ6GhYHjgTRUGAFGy5MYQnIehBfEOqx4TsSMSAW1agYzhAO38UI42jQsbWFzTS23qlE0xOmQoIJpu62AWVhbW+azKTWg0cFcrCfQZHGB2AnyO3hPoMn4fboN6M1SblFSLFhpE5qMysEbmq6UgZczZGVxSqIfaLQCYMuWLUCdIAwDQCE2g0ocyAawqIi8W6DfV6KuYkdxBMcDoZXor+ynK0kNfM7STgv/Jp+IO1RuOU1S/00O0VylVB9WaiK3GaGLaC45hPqQVEh7n5X6l1IK+uVfgc9ZQYDL3oRqM/D6styEVylPQrv+otRbjXiE9lDdnGOgpQwBeTGaQp/maPzlL38ROEQNEwPHBTlUdFgOOg1wopEKxBBeGscYFOSqGcQgEvpVeGUsiDMar3KrNTylCIWM2WYpNtRmiltJ0UttjdeJTa2qWr7KssijcFLzXKxORbRDoioDW8Ji9TPeVGRWEofVVj4YX/p8vE7SVC3bDUlkJJeFzAoiykF2lybKJUMlzI/oMpnNgxhrL62vb3hS3Fof6Eveqm+cxeoBCKSaQTCABlGcrCpl8alAvSgoBVkt/vpfTyuFMEpSa9XKuIKHfpNEIVBfz2u0G3trlfF6hIsqpiYVT/Yw/BqWGSoBL1pWXy9AiyAf34fldh1SIPODkFACn6pHrAyqrJcPQkFxa6BvfT15q3EWB8DrIdVqeSFHK8c+JZJXz4RkZf3FeoP/19PoIC8FrdHVyC/uAw35Z1I9yZMPsgovGns3PFmPDvLaBIUCpDq0s6xcj2C4yQwvvunON95FpX9U2Da+bqRrD9Ed8Ay1qx4Izkmob13Dk5z4CjmJ0mscrtbvDI5DuaIB/Q5w6oOdrgAAlJQeJEoPhsqjYKt12ASEej0aCgC1P5HSMrw0yDUuOO/pYRxAWYfSZax2O8vLUWY1IgVjlt+icZmWWxTUvMAswJNIwS6YNwhZFBS4jBdVsDo8TCE82KTfznCwaxioteexXAatdshDqtV6BS0Ho0gQP6AF5GKdIfF8UCPPiyrVOg0afqiSVEN9HLNgDg2aRlVUKQFBeT4AVq9rAcsbGapZa4XCCPZg9foS+EvNhoUfdB3GA5ydEHMh9HXjX5V8+BTLFzw9AbkYS/M8DR1btFq94AO50HV0UFIyirkNHRk41qrrar06eDBA2NuLSo3h7fYEcZPQQQAK8AwXG//KM7doefBHq18rAiiohbBO4kUG5R3vdSZLAvUKERQ5x3g9xKv4FCuj9W0h54DrIBoVekBWJt+CbQzmVa6ZqO2E3FysKXDBkuwtAj2IvieYeZfHTdje0A/wMHlR2fQOyRPvDD+JgiqVHPivaC1dFPgOPhUacl7V5i8sF3AMY73Wez7E7WE9z2Doe0rjd7XnVR4Oy6Hy8EUNBuptUFonMEkF9FWaJChpnLO0NJIXlqbhSFQKsnRufrE8Ur3E5u9ZjHJVKuVCcl53K4k8+2njjk+HsZ8QHYP0FBk98xk9v9OXV2najLbaQ87CNh9d1PwTejzUTqTytNoYIpQwPO8N4hmkOeBKpqHIxr+iyFUoMhxF1myGXxnDr05frjXMyGw0ie6Tfw59Qs+gAyQvdKIJ8qMDWv8DrixNoS3/kZShAjgow0TtAw7DoOVTcvVWRrOgcZkCSRmpHmWcclkHtYHcZHX3VvVEkEuUypRhrIMTxq3KibQ2xzfjRQVpjWuD4zskkZpxOOTX8gLsoKQJy6fBtFA9PJ4vWssHl4518lUKx0IK6gvOE5pcVKUASAtFCkB+La9KI4tCay69XRIX3bJKcia5pdbooUp6LonqQ4B5gVbwKFSsM4UeymhlikHSj1dV9qo59bRGvSXQIbzXWuqcVntmq1ogXFpH63oTruDp5DW1S7oWSMFyTFYsFWKgHGwkeQoL8sU4u4sVXPXJOknajIRTc1imA+s+WVU/51STsFm+I6httHL27pkFBS6+CcXKzTmFhM2StPbTVVCOA6hnsKAc3LnDcEozBvQD33WCO3XYKHokKVgDOlC/6tO1+IB8x+YmVphLfrirp5RDGZnZmBeLi2O1ikd5JighoQO8bijJaq+H+XgTEo8a3CCFXHCBoQChAji15UEIXaQdV6GL6OIq2pF/0I5NR/A0PO2IvIt/yLvYn/IuHRQ20gwAwwXcuErMbTJUHGnYeCQ8B6uHVSHmrmr8a9MRnoFrowNiEtcbJs4BPKhDUBsdYFqL2cfoetM7+FRIE4EVyuyc6ywxTA0p9Of9pp4nZXlUNdSG1RWyQHRWF4cQsro0+0O1uoJ9HLKkNIvCr9k6yg1KrmmUGQM0RdD6WZdC8kIpQQ2EwrQ9SHYJBozAddABpoOW6nRIIZMM4NtHfXQ6iFOPU1BkFMxnFPwuXHcR3cOpCf/aVDoat6nUBSvmuoo+6JwDTOcsDeoOtSfBPZ1e56gogba53lTGMNJpmxa4tKJoFBzwqdCJYZZXVTTN9UOBag1LYAorxqvKB+qYMWlzEE3yMfS4waobjwYtD+Tg6SoPqDAMwXnIdQ7A4OflFT4MwzJ4rrlN2zlMoja3nTk0U6iEmlvNybXLdb120WCq8Jhy0UvnoEQEv1DqJXlFjkoh410K13CtyHSVP1WE25TpBTZd63QivQ1a2FqlReuYaFqOW4ohrdi6llNyS5rY16m5NvS+qw2933wWxGnpKdTppOuSVkzRj1K4VlK5J1LjLmW2pcyAwZbina/jRT5vtuhzq3m1nApXJqlwLSH+5ysCClDgzSDMVnSpq8UsJsSELUaN2xakZHDYtDYjbT4328qHkAYxaO8Vhuw9dZC1Ni9zhc/LtvLRptp8B8JsPpdq86kDsg07xtZ8xqo361parlBClRQhw7WV+WizWbgKVJm7whwkZOOqckUzcVubg9vC5uAXQ2NSmQPoZJAy2oNmrrZ+xfGPDMk6vobFW6EuY5G3An2VpSwEJTh+Fr4OpY5eSTmxUH8RhPJbbMrJ6lYhW7TVJ/hRpQ0uu2jsDWtAYXR36NcoCmz6tReV7YMLMEHm11ZMcHDtyKSXFJzOWvmgJORiFgdXi4LaRVlhLFDWiWB1sT4oFtuUzK3KgLBREWb56yxddDAkmlux/F3NLP/W11VsrcvD5lwaph1s4dpBm3y0oh9s4fqhhc2s9VhhUEe5QnoqiI9Sni9GcEYKW7/Q0bJQr7dU7NRSYdor1FsunQbTsNQqgH0Qs3hUvCGkCj4h15eckZYlRYtSdyG1R+eEaEuExR2b5nfExkn2WPWOdbzqO64TzulEuKdHe9BpiymNwAVVLXB1Jxw6oRnfByvfjCRgHbpj3ZqaJUPjj3VZfNeqL+94olt59pTOi/ov2C0NSA5ce+LkkPGFfdNu7TG8h3/y2JnZJo8rt3+PKRULPkC14+8bk5c7dvqaKd6HFucgT0nJY3kddnkGTXjkThpTOqCqfVb/vB49brt1SvnMsd0mOGOKJhbNm7z0tZmwYsPvZht2C3FCBkSHjY2XiDXWjxxWSXA6JKe5wpIqWdQ7q5ovBfA8og+erDoecehO7B1HfY7U/nj5bz/UHkH96Bt10+9/+OH72XO8dkfyt+98+M03H77zbfKO2uPHsXXz6gfXrHlw9WbAJrPpmrjZsEJIErLBo5g5zmizGd2SKyLGaBQgagWuEJIlwRKMXwneW4qVO6WGDIWw8SjHyGZUTAKAm1DEMMRhl2Mvnf/ii/MTh6LE5DuGrsX9j92ZRhvmfXH+nvvuu4c9TmS8/mVjIpoUX3pMPrG274JE+vxDn1+nDbV7tjz65JOPbtnDWEgYIPQSZzHRGCck+qJiBadkF6ZGgbMMoXNuQZL1PI9Uk5FdaBWKRMGmRNIFgeSBYMjTZqPEBiQgx+xpk/3ew95Ze7asRmZ0cEs1LaMNq7dIU+gHqPMUSVePV0j32d1CtuSyJBjjzEYh1p85NY3VBg6C1eiA6q5gfFhc6/jgVf8QApay2XPvLO3mnbEATv7dNy0nf9Cdc2fdMXk+w6Viz+Lp/oc7dc/YWn7gz38+MHNLRoH3Yf/0xYun0zdQv+mLNZzEa4JTiHk5MkaQTDEwBiD2XzZWWTtec6KOMS7b/W3l5kUzNlqjrBtnLNpc+W2vCciCincfPLd75crd5w7upmfoLwL3keQV+xmczKqNeRkRiOQoKIHF4JzfJGpD36J/ePED+AG5iuV+iPHtTO45weWLEDEWjMGIncWd4ewav+3OZp79z5xfaEenz8vfwz138aOGBc3Gd54vpXdaD8mWJLXvIKCsLkabyxnRhw1wJeRF+AB35PQhRSHfig5wFhxDTDFYDVUMZzL1PRCDXU7Vq92xY8kDpN0L+i/qPCW7vNuWsi9X3bW4y7H4oUtq1qzbMRSPWn9hwfzJPfvlujym7Jljp5SzgX5rWt/C8UNOotpedz4yYZBnV4e8x0pK6N9yFj/knbJm+tjcvDH3yT/OfG3p5HlsSMc4J3QbO7N8yq239eiR1z+rfdWAUtbS2WxEdYHoH0IBSDJnJyk+2ek3JEsGW0WMV4owu2P8gluNQA6O1vg4h6i8ECsXvDIUejRnkbxnC60e1fWrEr9Wf9R3j3wWZSAj2nk4yn7fmFVPPLFm+H1xUd+98l9vnx27zOvMXZM2avyIoaMnjHHiL1AZWkSt8pL6+xb/7b+ufLz4vjRUSj+lv9J/0n+kpxxLSUdfLb5v5cKFK+/j3qdvYe2oY+3IEPKErr60dHuFMVdye9MSjYbkWPYjRNqlSFsFGyJqU1TPdvHFocDqRVq3eDSM41H3wgKryeHOgfsKBflFKJt9O//K36sfXfrX08+9cWlo/4kzRpQgS9eT5ddow8ydtOTBe56cTv8dYXnD+e4zj77V4fmtb/5l/7ZbB8wtH/LoCFq39iT977fo1wvWogfG+e9EhZGRQ4C3Mxm3rmXcGgteIyJMMRISTNaKKEHxuW8vVjy+KmyjeI5gxsv+1/5L/gYvO1h3CFc63tp/4kJtY754vhHijA9oyhRnGdOF7kI/Jhmc8Qki6XlrWruC/IiI7DwpO8ImgSeTzoqfNxR0FO7Wx6bLyeL1xRdyhaR6zFCoYkjDBqeWj70TZz2xZ9bM7+jPi54blOB/enD1Wm8e3fXUE6+/P/+RghvIuXl13G3Lej61oWNXNHDOxoGB42Xbplav3bf+YDXes/4RnJK7cNZzO2KsJ63WvgO6dI6e03XT5tVrUXzOkLuHH9kJDjh6D+jktS/yjn/QP2xM+qTpD4yaDOdakoRYsdrwID+f2EXI9sVlZLrT0jI7JIgCeFKwVghRkuI6l3u0U1x3ZSlRnvlnVr690IqBX5324BnwoDtdlYOZ8XsdTsIgO/vJo/X0+lsXL77Fnp+ef7Pm8B0PJy/NG1s69p678m5vn9BtXiyajvqj0WgBXU+P0BN053bkbGACzUP/Rn9poNcuHt694099i+cNGV1aNjkmaqc9ClZW9C3JhLuVvhR3gidHSsyWEjyJiZ4E0mqLOnfurHhIaatROTY39+8a78nxuBweF9gXbbanJ8pb8NCyqtfn3L1+/fpJv9WQz/GSWdO253967hy6cWjcuOatyBDag7chd5aUmCkluBMT3Tdrw2+2gGns34f/QwvWr1ix4vdg/8Cs+5fvQzcu+P0gP1KJUVzI9UU8+FOIsVgcUfY4kVitZiz4jRDAyap5gwVH49wph0N15MIdQDgKYFgScFnx+i506ekP/meUedQHm2OGPjA2hhgxrqyUKV5Nv0EueQn6mP6MImg2UK0b937yR+73P1vIFwp9mUmJkjvJ39Et5XT0J+dIyY6KhHhJSPDbBSnK7jdGBd2ftBKdS8e+jHvRzZyfVO4+enz/nZUpnIHvuG3MHQkT6LFwByjFAwYU9xg4kHR+5sknnga2HT5o6OjMnV5Kwt2fHBw3YNC4cYMGjIO9fkwwOaL6P4FY2wxfQe+0pW1vJrhs+4kT23e8/vqO0okTS9lD8KtPbnvllW1Pvlo9c8zYmTPHjpkJs4lrJIpkthIPGEI2XstHxkVqQGCMrCznRzwn+FAyGQQ/Nli1eMA8niZ78G4oIx8NleSlEfoxGOtUqWeVWg/MJX6sUwJVQotD+ZRovKJEDH5dtEulCFGK1dWRmWRSYF/jdPhk0v8yw7Ke0wukP3cTx93zcHJxf48Q6phNYYgSlww1GennKIWcJCiD/s2IrPjYQQgCdlAuVT2RKha7G/wuJprNRgchRoPETOTodlI0gxoXGoDFnUMRT9wZmcw0LsxnehD0N+scwcSkPHLGq5cCMTn5F/ru7Xve3L4i5V///exrTcK/+/93lfxj3Isnhg1YsPylP6a86przIBqC/B+8+TV9Zezdc3D3u8aXfHvwnnn0hqBrqQM8P8diItlxjMkoRZow+7EIfovSZO5yVvMGiRzqKWel9TA5c6CfzPTvMJhRuumkCWXTD1F7+t9mZEVxu1CvXQhTuou+vYt+zcZXD0aPSu7NJZ6fVO7oS0mzSwlp/qgEKSvKn5klZdorxIhIbPIbscoampcyGOKKhxfuiaYtHzxMCPT4ar3zMHvw3Kr9+6vWPfPMusK+fQu7+3wNeDIZjPvTSrRMPoGW0Up5y3MbNj333KYNzx0c5YP7Tb5RdFlVFcQZB2/J4k7Wc6nca110khTt8EdHC0Y2+o1+waqzXTpzc9OgxP7KhzmEyW3jKqvAKJIME5tfZ+NplH6FEuhPKBpj2X3H2gdfyn6yI6W1a+9AR8Y4US6KZWJ0KP0z/UdOHxv9YNijD718Ruwzlu5ED5Rw/51zxKmGNOUMlw0h8CVxA5uxeQ4/Igxet/j5ymHoUXGGiPjK/s1udqNHR2ycMmXjCOVT0N3WiW15i63F7bQWN9DCb/vAvS7xaPAmSD0qIZdFiHEjWAgcyoGrLahEvdWDmBF6gRwSraFTfkfwPnQBzl8iFIEWkMFignJKkQyWT+E+aAE/xYnQYCQQv7g+CPc7xnM2Nlk7g87QHiy9nJXdr5QFkpVDUX5Yk9e5jBwiNQpc9heDiJbBQVHekoO8JaIgFBGEyNWr/GzrQXwKHaOlMsfrII4jZvIAX9fnV3mOHj2K4+CyDkJ/RJuJjTTyNOJw4LLXXnsNbUbdUCH9M5RNFV4jT7R1+z7YJyM2ht++R2gh+pIUkwPB3eqF6BT6kt8PCd0c025kubUOh6vX2iVt3rZaNps6r55NdCPEj1mrLFQLDCXfkG/c/Fx46CA3WtjGuXDU8sR36E6cWXcnTr0Mp92Da61e1KJeuKrdWr05PGN1+K2e0MiJ1MaOIcuWZQiOIPkGqqAb6UbdSHr4Ejp06RIdz1sXHFHJLcfUb/o8CB9n1ROHDp0IT/Pbb4W28FtQwZtNWDd6TMDncC9BG0P8epg2kNSbYrpRoc/Pxwb9dtq0adoA2cv+KeeNNW63qPyexYQ6UpleXocj9tIyWhbk/mr0Ayg4VlOIz00Kp5t4XYzbXxswoL/G8RXsH+AV4vrf9B2hGwNTFHpNbNN3hG5UaLci4JbLQjgyX12tjI/qakEMRDRdI58xfecWSoQhjCvu8OXnRzulzraeqSNNg6VsU3Fyn/QRg25FaFB6ssmQamM/JI+p6FIyQMogjgqfOgXMDzrztykTGZs+mB/MDpnmZlPyrOyWc1iHMoc1hJLTbS1SPTDDZSYjMxSUX5T2fvAc3YzS+k18/Vk+0y0Z2i1TTjw+6jDaCO9vvfP1Z1E5f989g70f+dxXPZc1PH7ikeGfHSQB/mvKfDQbDenjf33Y0y/AJPi2YUUPFNOKpc/RczX0OydPLD9+29Mv0FOQWLywO0+se43+cOc89EDdVHRX3xr+KSA5jp4l25iNxS0s0SSJKytgEShkYXmUlVv5Sl2doaZhIFhngalM2sr9WcmToYj1LmfnLlLnzllipJQl+rPSpKwqPSRdxHrwsf87w7XDdNilXCeGqH9RzMiLu3NZYULfBV1DYeq7Luib4H7szgtf4TGzc9rPvg1/xU3Ich52feXC/iuGqmHXB60YNGcJD7v+4TsDKod18mXsSux7y+A1A859xtpTER5hPdLIQ6iZpIjWI6yr98Tkijo0FneXzxJBjbB+1HDi6I0vIMbuGQaxB4OYI05vegiioonTGy+AIfnTYJ1lC3v3HXxJMbFR0aIl0sxrtUDsNhOr1sDrVWOyKIFf1RNqTPy5QAb+NLiOpNfhLwyfUNr4tRinYAEPyjPslrecnYPWBz5Ejwr417lqX0ONbp8DRcdKOHpVhTlSMovQ9YoH4Pe02NSeoNNXN1Qq96+rM4799TA8gTxupssTwFmvPIkb7OTXbaxVm4KtyvYlRESaLaLBJII7XDCV14RzhNIeYAe1LQ1T6+rwSH1Lfu0W1oYQv/LYfTrMdYBZC8Kx13hX418FbSZx5HubfibDDdUc4zSf3WgSDSIiDBSRgj6BVTwNKo7yvRp+EWGoCSQQQU+Sd4Jxq0p9XQhulw4THF+7dKndmgox+f809yzQUZTnzj/PfWXfm8dCQp4kmBDiJiEEMCwPQ6A8NYTwKAZ8sXNShQjKoVRtsUqpx0uFI2ipeBSVSz3qqY/SNKW0entyEa1SpNYG5HC93F71YK5WHslmuP//z+xmd2d2MzM7G9tm2YyZ+f/v/X/f93/zfyV8lbligtfHMsVFuWU2e8HYMVTXdXYPn9VhtZvFvji4URruYFVZCa9ijjaOdK0qwW2tYrtaAR+I7WTFkT2D9wSePig8uvPL1/wn31zys5//6c2dzL9d/Yv3hfmAHPu0eDTyBWF97rzfPi68VCOcBsVg4R9baXC6dFb3zsP/6QSThKNDzxwHrBn8eNyBG9uEn2cJm8sOPID6AQaJo9Qx+gRRTpWLvaOpctQ7GnX7g3/ZB/8yBveLQr0vrT6Xy5oVImjaYgr5SZJlrRbeul1sTlIbiUeGz4AvcxVJZYCR0oHa4QK1OeG3j8EffAAxNR39SOd6C8vEDz7fO/JB53zjrp1HqbdFaMM0hnai2OkaQiv27i6nKi+3ou6FVCXuYsjhTu+voztwr+YnFO74Be4FT4ZpcBcVTnmaduR09jAtKmb0OG2CgmO+B5/uISLdKJ34lHd8xjsaabs0SNw46HO51Xbo63bxQ5NwvDvEj8iDDdQxJpdwETXBfLuDt1tdnMlJW6MHeFqZEOLBQ9GzXlHmBU/RUI+Pt2+oL0d7e+g4S7b30mfm8IUz3wya/Seo7g19BbndD7of7PYW9g19thX1aYyZbazSbIw1OhmcY6TZBp9iFlw4M/BLmleYjYzixhF5qJsdk53D09keAlINmDu4PNLhpHJZkwc1qPd43LwnMi3UYHxmp1M8sTNyUDiQQ0DuGeqkuq/e23u1m6u6cObKO+x8DAnY4AZ3ISiG/pEAFYWh2oehyoIx+ORgEQc1mnDaQ4BlSNricvIuC23L4imLLYRM+0ORBqAiZKK5jRw5jt5ALvNBF7K+iKH2hZup7qFOcs/gnCt97EVwVGi6ms2Vgh0byNytZHaf8Lhb2EVmd4f7wnVCd19Mr3TcnR1lAdziGfkOirOq7c4+ePCzgT8x+35x9R129+fHP2e+M7D8F2zz1dWK3dmxBCDszdIp7WbIeTPgWXPkBPTt8ae0l4nEhxOF12Nq/5B6JbwwQmHB0hMjw3lYhiGXs5zZoTyrLZd2cmh8CwdCTo53bo9Q0uWO0LGhvomCXAXSLPXVFObri3/ZOsNz5X/D28UpOY939rYPnoWc7Z/ZOskHYwVLFIAq0lnV1twPeQutx0fQRhRjGzEx3Cx1U55MvA7XjvnELvIi8xTWXNx5leWQ9iY5//09CXsQc/770Hx6w+Au5uDAauYg+LTvkvtSn7Dn7FDw6NFYPfYRU4KFdjdcI9wOn9nipR00gxu1dMCFlXM4bLxDFPMTlVjGRf2SaIEpUYYlvAxRQ9SyK38WxoAdpnVXLl7eI2wB57kpkrYJF/su7HTv/LQP+pGSzkH+vgytfR/u0FIXHEdarBTNcibEZYioA2KaBVG1QVzt+ED+wPD/pd6RUW0Tv0nxeP4rh8Tvl/tAwA0CfcKi48Ki4d8lbRcly0UEguNcNpLKcrKs2YI63IoiBmkBp40IWUBq1iHOOyxokZkHvsDc38PkDnx6dbqo6jGCF5UBhLiSXhMOOw88Dp4jKZa2Oj2808qYLTxtNfPQcbMO6/WJGL2W5i4rq2eQ8S6D8Fw+Is4NSEj9o+zFy61gB1d6NTvGzHz8cV+4e8je19ctrlSnIQ9eR1J4bQNehyZeHi+uZXgdAnBNFmH1oO4GXiJk84ZIYLWhs5CtdMgq6WAj3pcrR/DYKbGCoIDKYZGVefaDbbO9zKcDYz0ztp56QbQv/c1tVU6yqqcK+Ca1zoQyuSt2Fg/B2zzJZylLmGVwfnQay55vOpNPI82DZL8E6b+7sIj3+AtDJU5XMe3nHJD7dqj/fo73J9d/NKMvCkGcFbh0BM8dhcbckmALRDj6Y2EbtgkxVMgjqoJjbNk+PsubzZvzCN4E8nhLbo6VRh0mMWwiVBELnwAVtvfQxm+/8r/xEHEe6ocoW74BXFKABVzqF15wCwehdboIrdN4bJ2qw49J1mkqtE70V+ckz4WSTktvDJYWE6GxxejQ9xyad+aEWMbhdObl8iaOd5hCjrztXUDai6nEbXoaI9EOVUuBBF4mdiG5Opl93xI+GEWA+jg8HqNE32Z66hIR6b3eS70XDgiHFJgO2J6eoYcjzdYhZq1Q4j/GEl89+E+xf/d+pAkHZZpQfXkOxvy5wZXYI3vt2iVy97BPz9AcSxPQoYdiI/PpQb2ZdAFy90Ahc26wmM4e/MxC8sfJzqHxwmZqggDdROrKLhjVjJVFNdAE8tC7EaOauPgwGqUBcXTQ2htuHZ5AjM9AVcI89NfnhOOgPT4mzLI57LQJBoRwYRFjQjp1TCjOGD6EQsIr6xMnVZgYUVSK42UUhdEqoigVzoVxzXswrkGd5KqJJcFaU2ElPz6ruMQ/xmK+bkLBRJuzCBRCucrLc5by2R6Pq8Pp6sLbNXAhRJt8w81V/O9Gnf533WINDQyqRNdHXZte8P5AC3VyaDx9TAxrtr5RdWjWRhztPC2FN8IxUEZ+/zjY9ZHwhVugwavDQc0HWXevfqArX5gbjXzoF8zg+/l7xRDn/tK9D0DLvx5ifAxijPZbJxGtwUYoPMWALyrmiyAP8sv4avN1ldk5LFNa4i+3WQvH5bu63C7e6eadDt75SJfPWsXbYUznifa+Rv+LhnViY5W4iE5OgoSYDq6agzViTDdAI/wZWgrrTl7dFRfWDQo356JWxDisG0s+JNFh6P/AW8N0ODW0MxrcLRf2i8Ed1jsxgovoHYrtFhCi5kWivgQ5gVEg1rw4j6gk0mPHZFHoVXP23cqETjXkReQFDe6iN4jeEOg8CzqRSzT0PnSHkM1dDe1ZFfYE8l0E7+oAVgtJc1l2PosLohP/uQ7OxIv+LaoF80fc/shShI0X50M9h33SYnTC7P9m8MwFc/jSZ72ryaqt5HX9hV7s2+cWEORX56RVyIM7TZaYPDneMblus8mX5ecJqP+A7fDRvC8r6IIhjtPakeUkZmAXzB/xxUT1bBB7Avhi+wSUMdAhKyti2N5v6F4Mi5WGTlh/M7DYHgSWa8TXndcI5JLlFvSJvn6hV3TJ6vbsce/ZA+mNaXIM0gTBNz1YOjJ8iDiqAczBXiPH9l59XQSQbYUA/vPSBVPuhTOXT59Z3Y+A64+QzVvYP3R6a92DkHoPxvDLByErZt0ujrYBAjprProDLY62YBa0aXazrcPm4G0RpsVCJvlwIAYudIY5YiBcM4WpV14VoeKWg7eELZfX/vaPpn0wLgLuGJiAs08QOt2dQhhK9gK4cvRKK8oXUh5gC14xgsRBKPMXsIcL/Q0rlCYbklwouA4ouXaWyaLNUHotpOTfxq7qDZLmMtK3O1wNtbOGfJ96GPdemkP2HAQ9x0FPn/C2W3i7L+Z3kYcRj2oMUR3MR07VGOhVAZ8/L5tkoWuVA6HJjTpXYt+JmIgxZlGOQCD0DDsSxVfOiq7FY5FIUsnlktwL7FVIciXqWh7RFCxzQ3XLc3V4gDU3x0J6TZLO+SBg2Qlahxk4HG4raV4USr8oVPOvvHPmAld1tbt3qCYCY6IuSgzF0a7kA+wTOXlta5wlqh68LeoNH4RURXUfxXkFvL2C95TwHnseRQUIvioAvVZLFfJaLXTIEuO14sK1WA8ZVQoXwE8TVSt25LSTJcXVJHr/j4t3nSet2ri0bXPH+rnz2qdNWTz7D7d2BB+eunTx+iVrNq/qbJt967qg3OOl8seWVpfmlpTkdu1qhr/Bn/x8UuRJKl+HqsUWV/REX4V4LiVagjUVC/kChg/M4SfO40sIvqGJbyiZGCioYJ1eD+/3htwuv9nh5M2OkN8ccZ0rRUdPxFsqIolBzyejQ8K31Dm4mhIpMx5TKDw9Hmc5jdruWnH7gpkdy757Q1vnqs1rVnS1rQg6qrPq8prz5y2/Ibh2ydz1HZvb5u1+uC64oq2LrIolTL+cgrE/DPeMx4dICn+fNg3+g+Xh2iy6gp0P16WyYLYJoJqIHUkcFLxHkeOJZGNqQc0jgz9B6y31HrnoVLjvKKgG/cfBnj7kWtzBVFy5gvhwbRb0F+ZDLW4IlnJ22kU7GN6xowvaXbMVeZ4ewHsoWxZJQ6vnNotmJKdRdAsqo0EyKBmel8KBcrhk6I1T2wZvwg4PS7af2kE/Jq7yewfOgGzSFIFkERMU/iy4UKe7cC44Qu2j7iD8KEozu3hzVjYRorNhnB5CqhvJx7gacVYR+fCIlfXoBT9Wkm6fL5y7+8fT7tty37Q76PHhR2edbLyn657GmjpwpPmXv5u+ZPrqgu59s9pnrV0eQB5iEEcbzxDXEzcQ84lg8DoiwFdPnEOEmubwuWNC43L5Ei8fnFUyjp7Q5Olip/DWLDY0IYuf4JICuKgE4obIIL7wFQojLobFzeBKIi3iJjdMJmojpbKxu46eQmpyg7NIqjO0RQtin+zZUJ5318J5u3fP23IC0AuffHLhxCl59eCGsFg6myeVyTqGhmbcMQfsE4tnQXa0UPa7fz589/dw4znUf27VnR8CINXSHo0UzQq5pL9gvhDAtbTIJ5oD7iJ76G4chRUF3ajfVk6HycF7Kd7kteWEbJJH5JdyvBBukRm1PmcR5oXPhyph4EBPLdv7+N5lh48Ljy17as+Tbb0nmC3kywHQVV5XfqIgIGyF30cKhGM4CxxeLfkuART5+X18mZUvdPKFZX4KTKrhJ0wKXR+YIPZTDE3g+Alx1sAtWUExlEYwRKweV46EhRL1H/rocXF1cN2ts6E6b7plyfrFS6c+HOy49Q+zF0+Z1j4PKvO9y5ZuXDUpIc4m8/NFnW3e1SVp7Nh8KibURtlFgPxRP4w8SoPZWWN5Vy5PlfFcEc9RrizaWxHyeVGteI7UuBFEpAMZ7GgjwSLJMEVkCI4aXHD/Q63TF06bdnNw0X3rGx89Lpy68ac/vXHqzYtuaW68/0cznsFdBquryxsbyysqcK/BiorJLZPR78hnqAJ3QYl/FJ/9Ni7ogYrOWVFXRrgUkgyM0cSGcpEIGvXdKvKIuXthzz73+T4QBPbn6O+HK6iPqHVg59AL5ABqfYn3BUyDfde+oFtw7ZpYvTiTWEisIG4nlgYDTTfwLU2h6TNmNXa08K0rO0KLZq3ka2d5ulxOnnCF3A7WNobgy4vGhCaidzhwdWC0f21jZWXcRXzNICpUBuUgsvsaexZ0kVIDtByQA9i4o0KTPTKULZU+Uo90PlkYXrWaumh/cTu8HrxFqoWkF0m/CDZ0K7+3iNq/Ojw260XqcelR+a3DrdPWrxxqu5/8+MEn0MWhZTe2tLW13Lgs8h2+Dt13+wry6S1DFQ/slVVXDldZAmL/tS/ppbjD6bigy2YlOCfPkV2si6ClF2CwgohvvtTXQafAVejyQrWorytzeVnw8GdCU4Cc+/vWduHiTtexPzjpKuHOd481rf3JrwrCd9+2Fc7QS28C/8S8jTvpFaxpam9vgh96E/6CH1TT0Uv+Xro74bRvSunZJtkYwneGR6OIXmCNjlaSfLyUY6eaQ1gwPBuNZqP+EZ1tUvx8RSrmpm6S5hp6b0QgUgLDyGCZpg6aZOfmJocMvJn4l1QwKsDKKsA6Nz1oi3RCHv0v2lAYlgGO6L3WJsPlZuOw0cuTdLmkoF6mJLjekhls0+apUVyW3zMKfFdnJVLgqsaAqGI70lcFXNOzLjqx04dUDDIZ4Vuye/RgplNWlWQ0A3xL2xrpZpz+FU47dzTxQmlVSIPy6a3NyTmgDQWjNMa4tTtN2VJn1TPAN23enibrndpqMwq4aPdPNUGvDegYYA2iu35N16nxSjJkCN11artmwo8Uw6iBOxo/qVmuUwYGI9t4zWvXyLApEE+V669CZtNaaTVArmDktfp4qqy8YV6+Htx08klBRTPAOY36kMLMa2TciNZGs+UZGXptQGuMJNLyKtTDrlGaFKTIEMrr1XjNpB/BzmuiriZaKljOESmn1YMcGbKUFjLt6Dcdj1cD7BrprEdmtXq0I0OfylikJDyNYI3J5aqUWFXQqQNKkzet1ScdETaV3FbgMi2DVV0e3EBdjyEdhTL8MdCo84WT+rypXFyEedxcKjPyGnM2anIYaeQr0sgCqiGSnFmGZYq0RzAyyHVmqzOR4UuGjUZpkWH2r5fh0x7xy7DTJ3mG5CuM2C1RA3Z4bxTYDGRW097t0IaCwXTPoJ2KIbveHVeNUqFyy1U/5YzIqI9mjk1VVGO0zGYoy5bUEzJGapNm2VJ5ZOnZYjVgxSiRIfnJDOyjKNkmnXQzUN9jrU9KT1ZHritVEK87M6syo6Axk6A/25HsHjWwacxrGpRpSpOradPayFxTMmunBn65XVGfa0qltaOwpxCrtYbk6TKxp6Bg8HRSzkidjyEdlWCBklfnpcocqMwYaMlajGhTZHOrzP/pzvhoshnJoRuVnM+INkEGXyqVS5bzicvdGV+HmRAV6Ml3pZ/bVtBgKgGWDOhMDOpkXL2rnurZBP8mub4bkamLmUxDJKc+WtIbJWnL1emLhgyrW9Gc9dHsJ2iB/VuoL9KKj26+/AtUGGn1UzThl1xRM1JjlFSPNcKvDWz9GRA18GqVrabEv4xSBiSpx5RZm6Wh0khVllFPLJ+xnKdxmTs5iMbk7fRZxOSQa6KyoVk77d6HCiuXkuzfVs5uGCgtVT6jmrNTAjFtuqWds1MkXGqfVkduKs13wozKLRlVaZOJ7EJma23S8f6My9oZU21jYFbMoHob7ZJrQNZOZ/5Fq3+Wbt4unfxLmlZHV9WNutydugyVUsJALe66KvhSWZPU67amvJ0mq5EcNlV0Si9rN6JNkEEnV7mUhMtUzk55XR7lnF1KlyVjOTtF1En0fnx0tuS+kcwHkrs86mvrVMZ5KYvr9ObsVMb3cslJZerSiH/Ve536qtOMzj3oq0NLs/4sQ7kH9ZGSrgqztKsv0smNZKL+QpWHaFTeJs0KjAzpvK4dCt32TsO+UubkJv0cwCjIjWFZAEPlJmkWIPkKrz23JJ924Hx0Mp35j7TznMMg6MBbt77EIC6e5aPs2aSOcxQP81GduUkdgcp5pqf6QJNHqMZtMDT6VeMhqIBuVKJf9e8dJn60VR9kOOenYZ3IZM5PawWCMXqTWIGQns7HVxxliHO6olDjOac/Dk2Hc8ni0Jh4X0/tSKztVx1Da803KSxrZNxcumQuBnQgnkBHfZ70vDry98N4ShU3+G4tVBseIzaG1bXGqfFLkq1x6VYUa/NnR6oo1nfWg8H+bCoghzllUD1xOnTVS2kF3U/rtIeM8iUDxz1kgncG1txoZJ3xteD6am5U1oIbRPsM1dxofd/S8LcgMmCzNGRs9VFYFT2VbKjumEa91ZTBpn8zWqPkjnLdjda6Q0Non3bljdo6AAPiSS21NyPEk7ppZ2j1jdrcvAGZjLR1XqECR/KY0869DTvS8mkj9i46V2Zyb6lAkGlcDCyjWGOoBkS5rYuD9duuMdSGgsF012npNJI9oqta5VWbnUsFlNzKaaebAVZOHYhp002jNqkkXGoLpyNvpJQrUI27Kjokn1suNKqikeRSo9mGjAybAoNUmQadlFOZa9QIVaTeRllqNNfbKE2qwdIYU2+TGoh4zJPpi/Z6mxFQV7krlareJp5r2s8AULWjlsTOpXs6q6Zd1JQJO+NPPNRXcZP5zMMoVNyMWubB0IobDXmHdN9jTzfTrKXi5lvLNOuouBkFnVddcaMjq6Xi/Yl066j1Sk76sX+aa4EBG/FGVPHrlJ6kvrH2PU1tO1zxb5XryX0YkO9U0mRdu9kadSdWVyVPR2lvMjWG8kBHfdZGJewp0zZa4rl0tD4TkbDhOp/BWDgNjdcQCyf37Y3I9sm1fdSzfSl0PYP6kqDpMdqpoQJCsQwhJezqx06Zv9AQi6aZPTE0Gk0amcrml0tssmg0JurXUz+S4J2pi6RTxvEKFFMQcTJuLl0yFwM6EOtoyIakVTfAKpP3dGL4dM+1io7dlHwOPVU3mmJN2dzG78GqqiXVBltG92C1wquRrqO6B6tKFrTB36QTak1v6I3oV8jgUweWljhMDTzqeC8zi4ZHYZrOAtar8wo7FBnIWhqYwdAfw6d8r/VfJfuj7oSU0c7+pH6XOmPRu2JF8mhH76nfYMpc9K5ci67Sp08Vvcf79Nr3JFXFIwbuSeqP39X0xNK+J2lw/K7OKzBgP1dT/J561dcVDamJ31OdFKwGd0Mi+NSrtq44WKPOKGg8joE05euGQ6NYfUewS2OlnXeRzyDnWnSuzORdUoEg49nIeKvkWUrEI9G7EsdSn8lhVRotJex6Mh8KsyTArixtqeN3ReAB2RM9xYJQpO3wegfnJnuS7cGnjBcUt+AJiuxRF7+nHDvVHBp2pJJWaqiZOwP7UWrgSRkHyWBLJw4ie/TQThXf1PFPtTdrTN5H/V5UBvM+ivnpBE4YrzNx+ek4DdWj7wpZTuP5picKMZxvI0QhGeJb0hhEzZuVqfKsMW9Wqo6gNGcdlM46IOMopUfmYt9nBeKKJX8rNPp83FuhoryPlNWXzZ30rVDt9XHJZS49H9wgeVftg4tc1FYVmVTeVXjgavY0UsXc8rfXMxBzK1l0Mo5SemQu1sYCUYLl+zHR5xP2Y9T4kqkiF/l5Ddr8YFU+vKIfLNJtJB9eRjdlHx6IEQHxI0Q3RsmPPhy9WaIavjcn/u7UmB2WYwFELOTzRp+OPnTtGthPfkwtYB4lWfJ3BAGvHxcWkMcJAV4/ia/j/k4A8CplozqYo5AzltcAxQNiUmXN9QDUUuBVYH/2CcpG/mpo0bVrxGH6HM0y+0mW+Qo+RwKCPk29ypzH+NnfcBMsbyOISYHKAHw6GbbXNSxe3DBl0SKhVPqFPo2/pkiX8BtCdJI+TZ7FI1teg8MSIkQx45DtsscRJkX0OfIAuxpjQoDIc1StB3xy9BQEH2wTHkL3fUifo26W3eeBGH94+NTRyH0k8Xd43zv4Pg5iyMBb6SiG8O4i+CGXP3H28FA3/Ed8DD8KgBs++TR8kiWcbzI0LU1S62rET3pKyjng7n+p/1RXl/jY+fNEwlMUw0hPBdyNGIucBjgdiZ451Y+eOn9exMYC+fACO5twEc5fZxE0T5jxYxE+1Nf6vNm1gcn4F0i5A6+8cvOChTe98gp9+tBTlZUr1q5dUVn51CHEUZ5+mWpm10C6ewhP0OKEHHWGCJs4XAILygP1dSXFPi/ZvvEHP9iIPh0dHfTLG++8cyP6bLrt9ttvQxrzOX2c+g92PpSRMUGnl+IJb8hkDTlMPOEIieOikT31dbWBnGwIJwazpHh8+Xg4uu/zkzfeOqUme/JLPeOWNyytmE8fXzJw/dicNdOX9OcVTFw/Hc0gyWU8Nz31Rb7D1Gr6XE8PotFtkLIcux9C4fy1yc4TplAO5iRCCqI0ub4OTseVTxaRs5M+H7g0ub547Lza2eM2zVyzsbS6lD5XWj+jrshfUHlf8QR+ec20ibXlZjT2F/QR8iu2TkGavlj5UoA+EpG6t6gHqEeZGUiW3gR0CBBY1dC95Q2T62udDPgmMP23J4XnqQeet4z7SnhoKnrqpLCaPHttPdYFluDZ5LogrI7VhQNCIXn82iZRq4mIViOoDiw8u1koBK3CS8iykEIhtY24Ho7vC1rhjQwImRjeBOd5V+R5PWJ0Qw4H54LW9NnW+wteEgqfaJnzZdmG0u0fwpn2C+2Umygk3IQ3aLETvNkeMrFmNzGjtnZYaBrqG3zFrM9bG2jgWPLRe37QHOzn791UMsk9UWi/fdX829zNZGH7knbrYTOyURHbwjKnsc2KWASW+Su+jmg6y3yEryMazTJ/Q9dRzWWZj/Hfo5rF/D3hug9fR3SIZc7g64gmsMxZPF5EilnmE3wdkTmWOYeuo1RkmQuijZVowjL/g2wlIbBV1MvcFE22siLRVrJVSraSrSLP4pFHspXDjyOt+RI+99/c+ASpLSvKAV8LYeDvY6sGBrCthJC/I7uvoYgBH/YBvxAW7yOJq2wVvRDfh2wlIJjQsK1sKOKK4Ifc/Qzw9w5tQv+ix+CDAFBw/F9zNYqWEtQCZCkpQL8E6LPbtrFVgBbCu3Yh+BFFfyU9l2grAbKVSLTD8KGzCEZA79olhBE+FWwxtYObQ2RBS0ATlhDBxVnLWtFW1iK6/ezAK3NuaJr9ygG2eN/OeUuXztu5D1tJ5n2qmevUbyWZ9zvXretEn00rV61aibD5K1tA/Y1bR+QhK5kNrWR2yJwVckJL7ky0ktkJZhLbyb+enLBi6rSmPGgoi9fMrGzxz2cLAgP5Xu+4NQWB/sIcR8H6AjQP4ubf2X/IbeWHFMtWSbaSuUrN5jYQXoid2WrK4i3QXGLiYiLV1zUge4nNZW0A4sixPtI7q7zwpo45s5f+8r8mz8xnrvqKJuYVOWsr7/vOc9MXj3e50biP0G9QS9jNov2DFgmZwHj795vA9HePCc/TbzxvKf5StH+XnyE2UMeYXGIp0RKsmWPlp/r4mgK+spSvz+NnOPkZ9ZU1U+ewYNFivmVRaMnSFg4OzYFQC8e3bO8iEN1c7sbGykp3TmOlRMaG+iaqob6aLCm2ww/6Zlnx204hkjYgAjeRtYECMv47Ozunvpoqrwc+9sW/bJ3hCa67dXZb56pNt7Tf07YiWPfjPfOW3duxfu6StcEbls8b2+yvs090BFe03dN+y6ZVnW03fHfZ2uCC21fcvWzu+o57ly3duGqSd/a2D56lujf0z2yd5ANVZH4+XGjgz7Rp8J/ckpJcu/8ZjhH/W/RnbD5VRTqr2pr7hz7bCun6CbRlWewGhfXnk5Wn7oKewi5hA7L0HEtTOVBjZPeRXMFXK1kaVAmnFGxp5JpkWYZA8eoO+jQdwF6RgxgDVw1LNm3hKcBTTpqYVCupEhw2mcsLjv/o1BPCQ5JVIu+IuHLYEbLITByU2iFonV+D1lmFzr52qKdl+Yrmnn+nT79xZMv37r73N68j2SOg1r+qTuufe+OtRXPnLnrrdaT17bNmtUOt/3/vLPotAAAAAQAAB3c1w/mIN9tfDzz1AAsIAAAAAADYz+FlAAAAANn85G7y4P0SBWgIsgAAAAYAAgAAAAAAAHicY2BkYGDf+U+BgYFlw6cHvzezZjAARZABGzcAod8GkwAAAHic7ZhdaFxFFMfnrmOVPmmJYuMHFhSCdLEPfpaotUYRu2goQYqIDbIPMRgJGmoqWBINmIcgJUgQWWgeQlkKwoJF+tCK0CJFRKQ2KG3F6IMvLRHa6jb0ruv/3PlP7tm79yZrTOlLAj/OzNwzZ87MnDkzG1sxI7Zi8teQB8g06M1gWul4uVpkjTkBnqQs09fyf0D77hlN1Ldat76fNFP37YVrxHbi696nAuesGc1ggvrdKSRt/B82g7YUxP+NLTCVIM+98es7yvasWFgNbiMSG+MZiN4e1SdLbyV0LeGb+IRYrx+zrZ2Zk4n6IYVu35XBoI3PibEN56a+dZk1Wk3a1NjiVzKGSxl0kc4UsvqsBPHhuRT6waMtkJbrLnLufo1L/LbXVqpHbOXSzU7+/YetBHeBHNhk3Znxdg4r7kmMcSfYZhvzmT/H91uX73zemFB+dds4Hn1u8v1GVD/RN6w/TDnKfrfaxvzbRrvPu3I9pH/ers8PeqwyffO5oZdzzFNP6u85vaAzxnTYxtiSub5j0++Gp+i334OyKr+i9i/PvfZzHySfg6Nch0Ha28W9FBtjtvFsit5bYB/LYvNBNa6Pdz9WmX11nPh4KnENZH4v2cZ4Fd3dlINsE7nTxmfd++Hj6bAqT9k4NrwPeRvfkUXbGDdT9NvvobrP6vVsItsbbXzfibyPfh0EFTXvD1h+hvNZBz5We6VzlejeCF4Gj3M9+9kuvMbvnnF+L3Bcvx9D3Dfx533r4lf2dA/Xc4hlyADnNcB4wRMAaxFso0R+Cl6n7Lp+etGcdxJf9m8O1IMTYDKW5hGWT3C9P2N9C2PnSzDMWOhzBOshv4WU+PoecsjVzS/gR+oKkjs7CNsCGeMr6+40yOCgawt8HIqtC26MoB38bithn8uRgpR9XcsQ6xEiHmtvQuJ8hj+jjDhbuAwd2LsCH2rDze1Sj5hD+7j7dgW+hRbfeyDPEdgOb7eVq8hp1YKTQjR2T+xXKlsc1RGWsV/VM7Hvi3thFD5P+3eKxKTPu5IH5K38onW5spdrbbiGA9yzQsKm4fmdoRywcS4y7oxG+97v9qou572LvhUVexP1Sfqwj/tXTPAdpX8XiV95nucpnt8Sz1jRxaS5F8j76A3wNef3NNuOpcxrBeSQw217XM7SSe2/g+iyIuqX0t6E4ZrvyLBPW4v2lppTd1wONifKrfhCRL/lPv6N/xuRMYcpOzPqRrV3KvkhOE75Q0p9GV8kXgXJG77s67otqxzVxxy6LWqfb26XNpPSJ6knd3ekI/rb0/WXs5GF2Fz0Ra+t93m+WbfBr3nl13zzPJezsaRv7SltWes7lj1Ow36NZej4+UuOkbfFswrJc/4thvvBPKZ02hV3g4f4Bpc76BZw2WHOsb9I+c3kf4frM3kauut4dyFfB32uHp1Beb8eABgjeFf1S4tlbfe0sxXZUP1DjFHDfVRDPq29Db6xlb+gt4D3ysKn/Dbg9ORu1PdlVOb9lmyv9qh7Ve7KF1J0jtDm/pgQ639xzt2FVdwv4Re4R9F+aY71OyD74u+R3f2uz6KNQsLuDOsz/M5vYkvKMvfwVd6xyFdXZW9KXLeTa6yxxvUidzRGtyW/L/VtpX2j3xOTlPLb8pAxgQGnwCYwi8pZyA1kPehH23kgukVwARxnnwPG5HKQJfebJzhlo//RBLOwfRZyA5G8L2/n8zb6PZmTe6QEm/84O+ZPjr0AeQPbOzj2T2CWY3+EPDcN+SvGvcmNE401Dp2azAVl/P0LwMzxwwAAAAAAHwBNAF8AcQCMAKcAwgDeAPkBCwEnAUIBXgF5AZQBpwG6AcwB3gHwAjYCSQJdAm8CqgK8AwMDOANKA1wDbgOAA5IDuAPwBAIECgQxBEMEVQRnBHkElQSwBMwE5wUCBRUFJwU6BUwFXgVwBbIFxAXmBigGOgZMBl4GcQaDBqgG4gb0BxcHVQdnB3kHiweeB7AHwwfVB+cH+Qg4CEoIdwiKCL0I0AjnCPoJIAkzCUcJdQmjCccJ2QnrCf4KMwpoCnoKpgq4CsoK3Ar4CxMLLwtKC2ULeAuLC50LrwvCC9QL5wv5DAsMHQwwDEIMigzcDO4NAA1SDYMNtw31DjEOQw5VDmgOsg7EDtYO6A76Dw0PWA+TD68P3Q/vEAEQFBA5EEsQXRBvEIIQlRCnELkQ6xD9ERARIhE0EUYRWRFrEa4RwRHTEfISIBIyEkQSVxJpEpUSuRLLEt0S8BMDExUTJxM5E0sTbRN/E5EToxO/E9ET4xP1FAcUGRRuFIAUkhStFMgU4xT+FRkVKxVHFWIVfhWaFbUVyBXbFe0V/xYRFn0WkBatFr8XPBdOF4sXxRfXF+kX+xgNGB8YYRjAGQwZXBmfGbEZwxnVGecaAxoeGjoaVhpxGoQalhqpGrsazRrfGzobTBuPG8IcExwlHDccSRxbHG0cmhzXHOodIR1BHVMdZR13HYodnR2vHcEeFB4mHnkeix7IHu8fAh81H0gfeh+kH7Yf7iABIBUgVSCYIMUg1yEQISIhNSFxIa4hwCH0IgYiGCIqIkYiYSJ9IpkitCLHItoi7CL+IxIjJCM3I0kjWyNtI4AjkiPiJDkkSyRdJL4lACVCJYQlvCXOJeAl9CZBJlMmZSZ3JokmnCcGJzInaCetJ/AoAigVKEsoXShvKIEolCinKLkoyykQKSIpNSlIKVspbSmAKZIp4in1KgcqJypWKmgqeiqNKp8qyir+KxArIis1K0grWitsK34rkCuyK8Qr1ivoLDEsdCyGLJgsqiy8LM4s1i2yLtAvTS/MMBMwRDBxMHkwsTC5MNEw4zEAMTwxRDFWMWkx+TJNMnEygzKVMuoy/DMlMy0zNTM9M1ozYjNqM3IznjOwM/Qz/DQlNEg0azSXNLs07jUkNV01nzXeNeY2IzZjNms2fjaGNrU3ATdRN4M3rDhBOJo4yDjQOQM5OTlrOZM5mzmjObU57Tn/OjM6UjqfOqc68js5O1E7YzuAO7c7vzvRO+Q8cDzCPOc8+T0LPV49cD2YPcQ96T3xPg4+Fj4ePjo+Qj5UPr0+xT7sPw8/Mj9eP4M/sz/mQBxAXkCdQKVA6EEnQS9BQkFKQYhBz0IgQm1ClkMoQ35DrEPRRAREOERpRHFEeUSBRJNE1ETmRTFFhUWNRiBGdkZ+RolGlEbnRwZHDkcWRz9HgkfNSAVIQUiGSN1I5UjtSPVJGEkgSShJMEloSXBJeEmASYhJkEm6ScJJyknSSfxKBEoMShRKHEpSSo9KyUr9SzBLXUuUS8RMD0wiTDVMdEy6TQtNQ02XTdpOGU5HTnlOok7UTxpPVk+CT9hP4FAVUE5Qk1DOUPpRKVFvUbpR8VIzUkVSWFJsUn5SkVKlUrdSyVLbUu1S/1M9U3xTolPXVCVUUFSRVNZU9VVPVZRV0FXZVeJV61X0Vf1WBlYPVhhWIVYqVjNWPFZFVk5WV1ZgVmlWclZ7VoRWjFaUVpxWpFasVrRWvFbEVsxW1FcFVyhXVVefV8hYAVg9WFpYpVjhWPdZTlmhWhlajlsrW7ZcJVxBXFVchlyvXL9c6F0RXVtdpV2uXdBeAV4OXmBecl6GXpteyl74X1Vfsl/PX+xgDWAtYDVgPWBQYGNga2B9YIZgj2CcYKlgtmDLYOFg7GElYVthfmGgYa1hwmHdYgNiN2JVYoli0GL6Yzpjc2PbZINkrGUYZUBlTWVeZaNl8GX9Zi9mPGZNZrdm/mdPZ59nq2e4Z8hoAWhDaE9oW2hoaMto12jnaPNo/2mBaipqmGqlarFrRWtSa79sG2wnbFRskGzBbM5s32z7bQ5tF20fbR9tH20fbX9tzm4ebp9u+W9jb75wGnBgcKRw1HEucZRx1nIxcoly1HMHc1Nzm3P+dEJ0rXTvdR11YXWIdcl2LHZrdnN2e3aidqp2zHbwdwd3LHc/d213qHfGd/14JHhLeHt4rnjWeON5EnkpeUd5nHnBefJ5+noCeiV6T3pyenp6hXqcewR7kXu5e+R8Dnw3fHF8qnztfPp9B30UfSF9Ln07fUh9VX1ifW99fH2JfZZ9o32wfb19yn3YfeZ9834Bfg5+Hn4yfkJ+U35hfnd+h37Vf2iAj4CrgNeBDYEzgVmBgIGmgbmBzYH4gh2CUoKHgr2C84M1g/iEM4SIhK6Ey4T9hR6FQIVbhXaFiYWcha+FwoXSheuGAoYZhjCGR4Zoho+GnYazhsGGzobjhviHBYcah0yHaIgsiE6IcIi1iNuJA4lciWqJgImViaqJvYnRie6KDIosikyKbIqBio+KpIqyir+KzIrZiueK+4sPiySLOYtdi3GLhIuRi5+Ls4vIi9aL44vxi/+MFIwojD2MUoxfjGyMeYyFjJiMq4y/jNKM840NjSeNO41bjXSNjo2ijc6N7o4PjieOPY5TjmaOd46Njp6OtI7NjuGO8o8JjxqPMY9Lj2WPe4+Rj6aPvI/Kj96P75AAkA6QHJAukE6QdJCCkJ6QvJDKkN6Q75ECkRORIZE7kU+RY5F+kZSRqZHCkdiR7pIIkiSSQJJckniSlJK3ksiS2JLrkwCTDpMhkzKTQ5NQk12TcJOMk6+TvJPVk/GT/5QSlCSUNJRElFKUa5R+lJGUrJTClNiU8ZUHlR2VN5VTlWqVf5WUla2VwJXWleaV/JYNlieWOpZQlmCWdpaHlqCWtJbJluyXBZcflziXTJdgl3qXjpeil8WX3Zf1mGqYsZkFmTmZg5mvmcaZ5Zpamr6bHZtFm7icHZyAnN6dG52EnbWdyp3pnf2eHJ5DnpGey58gn2iffJ+Zn7mfxp/Wn+Sf8qACoBCgHqAwoD6gTqBqoHigjKChoLagyqDdoPKhBaEloVGhZaF9oZWhsqHJofWiCaKvosyjNKNdo2qjpaPVpAekLqRVpMmk1qUgpS2lPqVPpW6lmKXPpgamUaaXptCm+qc/p0ynfKfAp/2oPaiCqJOoxqj6qUmpjqmbqfuqB6oYqkCqdKqwqsGrOqu3q8Sr1awDrD2sjazbrSStMa1vrbmuCa4arn2ujq8ir1Kvma/SsF+wm7D/sUuxerI3smiyaLJ/sqay3bMjs3mz37RVtNu1UbW3ti22lLbqt1C3xrgsuIK46Lk/uYa53LpDurm7H7t2u9y8M7x5vNC9Nr2MvdO+Kb5wvqa+7L9Cv6jAHsCEwNrBQMGWwd3CNMKbwvLDOMOOw9XEDMRTxKvFEsVpxbDGBsZNxoTGzMcjx2rHocfnyB7IRch7yMLJGcmAyffKXsq1yxzLdMu6zBDMdszMzRLNaM2vzefOLs6Gzu3PRM+Mz+PQK9Bh0KjQ/tFE0XvRwdH40h7SVdKc0vPTWtOx0/jUT9SW1M3VFNVr1bLV6NYu1mXWjNbD1wvXYtep1+HYKNhf2IbYvtkF2TzZY9mZ2cDZ19n+2jXafNrT2zrbsdwY3G/c1t0u3XXdzN4z3ore0d8o33Dfpt/s4ELgqOD+4UThmuHh4hjiX+K14vzjM+N547Dj1+QO5FXkrOUT5WrlseYI5k/mh+bP5yfnb+em5+3oJehL6ILoyekg6Wfpnenj6hrqQep56sDq9+se61Tre+uS67nr8Ow37I7s9e1M7ZPt6u4y7mnusO8H707vhe/M8ATwK/Bi8KnxAPFH8X7xxfH98iPyWfKf8tby/fM081vzcvOZ89D0F/Ru9LX07PUz9Wr1kfXI9g/2RvZt9qT2y/bi9wn3QPeH97735fgc+EP4WviB+Lj43/j1+Rv5Mfk5+UH5Sfld+WX5kvmu+cL51vnz+g76KfpO+nj6qfq7+un6/fsY+zT7SPtp+5P7m/uj+6v7s/u7+8P7y/vT+9v74/vr+/P7+/wo/ET8WPxs/Ij8pPzA/OH9C/0//VH9ff2Y/in+Pf5R/ln+Yf6a/rv+3P7c/twAAAABAAAGDACUACUAUQAGAAIAEAAvAJoAAALND4MAAwACeJytWMtyG1UQvU7CI+GxoigqxUKVYuFQsh2HRxVkpcjyg8hSkOyELEcjWZ5ElsTMKIo3LFjzI2z4Cj6ABR/AR7CgWNF9uu9jNJJjDOWydOfevv04fbrvHRlj3je/mOtm7cZNY0yf/mW8Zm7Tk4yvkcwPOr5udsxPOr5hPjW/6fgNUzF/6/hNs752W8dvmR/XHur4bfPx2q86vmk+WPtDx++Ye2t/6vjdYPzeh79f+0TH75svP/rL/ExW7pt7Ztt8RaNDk5jYpGZiMvo/MTnN1WmUmik+I5pJaDQ2m7RSMyP6q5gOzQ3NKa1leBrQ94CkX9JnnyTrtC8jvRE9JfQpOvu0yrJDMyMtEcmzD9v0t0kebZNPD0yXbHxD/w9KOqyGjQUdq21VFiSfwMdM46mUrP8fFhMgwnM50OPZM+x6QXOMMK+cQnYZ9kM8zwh9Kx3T9xk9R+RzAqQ3CaXIPIeVI3NOawMzR7Ze0GoN1iTCh7TCGeNM5ST3tdmiv0x356W9m2ptmWcZvJqStgRZrtA8W8nBjGfwuoJYz+l7BkZIrIKJlea5CeJKSYK9GJgqPfchNwXG55jhiNnOlCQT3RurloE+R9A9RWbPSCrHGu/qwQ+L9QgR8S7rl+zIgHNamjlxMVQvlbcpnvu0J6bnKvCSihC7VWdnMYIEmZoDp5g+l2M210hZOqZoZmBWfyn2vGeE0TrJ36Vv5mBPcVmmXXy4KrZeex+ahjSXgqk5Mhe7HrIsAmu97NeDgAMcicSSw57tTqxfYu3TzByRT1B3F3EvKrBqgLxM9FOikvEMVTPDTvbWZtPqOUV9TS/kqPTNsWbGa7cVkijKzB/2twekJbe3aOUW1bjgzFGMEN/c4VzkdRW5iTDuKxN8nrrmwDTpu42c8squw2WxPtZdz8hc14gR4xRdfxN9dETfjNuQ1tukrUkZksr1nSJzaJXzIdgIbyxHIpwwF9Wr5XnPoTJTlhTj3YPWfVrtKSOnqNkE/qTQceKqv8yVMgZD7D2FRtsrt1AbxX6whdMhPCM2IM0c2qK9nMMedkaoEo5ti9A7oJOkYVqUqQYhafP/2FVgFpxe4q2waaAVOURNjJU/VUTDq4PgNDlF1QyVLbYehJ9TPSHFAvuY01qCk0f4Fim/p8rnsC96NnUVhzlshZZ8T+W4uQdIr7c6q8jvIPDQdxdZmwDRE5VNsZK4XtNDtQ4K50emp2C4255hVoYZVF4VryyL/020GTjynJ7ioO/kF1SydI2wEph1woBtdL4W7U2CDvJ6Tyo0L/yOXAc6AXdy14vZIvc1Pruk9uyNg7VKD8sQk/TpNnAe4knkxcJhCb3ifSvT/IW1mwEHf6KIX5ytE8f++4j96lYvn7dF73raV0aOfavY5pm0pX75yOaaM5+DbAlfpP9LHvw5HcFPviXJzcBXnj1jpDqzIL6IvJrgJu7lU3dfF0bk7hyz/Pf9r9h5uUPL+ZOpxggs6OnZtXiWFxkqN4gMfrKdDeROeCU9/RV8OsFZMlCOcH89w44NvSP2EdUIu051RrJseeDvEAN3/qSIPkX/zV1+Y0TKHizTzr0n17kc3U6YxbnMgmxaezYC8aKn/LRni43KIiGxD90za5ooskU7RZwHkLc3nZeQnC+9i8303mmr5zPtHJNL1MpVKiW859s3rvBdMNTSoj2M7zpJ3NWeK/hkiPGV3hliYMxYp+7WOTbhTbR8DhZPvkVUYuRH7qRT12clE/UlNbKv1StISgWIneX32vDOvfruMzD2nngWcMSiM1Z0/L07VSx9VEVdNteZy/bnwNXeF8cLeBez+7q4/a7wrKmh451idrnei1iToafJWSx9yDJ85u6sEqNU7xlk7D1gjDt+qoyz51ofTEuRi8z1tPNL8L2qrItxMwzfDmJ6Gx7jdJbePyxw3PZefwKIvv+Gc9iJVyOdFk4UkU0we7X6scz5osCci+825XvSRN9oyncof2+YQoPvlf69dwKURfMM1WVZseqslZpI4NFI+9BY8Vx9loV3Qm+pyMNVFkP9/i7lT7pVp6Z0jO9pv3h7ZuzbtX3zsB3A9wqRixShy0Qmb7/Sb2w8tg+dB7weuzflGGes9SX8Laav1Wj74+vr2r+n7tN7C0u2qdcfQZLfCo/MU2JzB2sHNFehN5oOrTyhpx2a3aGZOyTR1fU7yNRTGrPGtjmGLtHRoU/W/cxUoLuCZ356RPIt0sV7G+Y72GiQti4kO9B9SLP8ltVQOd5Rp5ljeubxnuHfzMRei3bxdxP72Bfx9IjmvdWiVwewaD07pKcO6d/X1RrpPoA+9r8KpHjccn7uqqc1YMSaj/BOeEy7alh5TOMOfbbxjih+7Ki3LcSwS+sSSwMeSCbEozp9PybbLLFHfh3BC7Z0pJJVRMjx7GA/W32EWfGsrVnmsdeyqViKH4z/E2e5i/ib+OXBMqTsRwWZbsJqB1loKPaMWtPxqhNgXwcqnB32b4fG7O+ey8Giv1ZbMQfLOGAt7CGKBvBoQrpLfjdI/sDNCOsOwLa6Iig6hd2S+WaAYR254vx9S1YbypwaECpGIXXA/vsoBOeaftaxt40nn+OW5rDuMtoGl8qoPEXFNSBVQz66DoVdVOmhen4c8Mjm8VhZ2HaeFfG11WLlLtMhRJe1Xcwg41mDdvaw69B4vd7Nq/2e9Q9nNlrDeJx9PAd4HMXVs3unKSq2LMmy3A2hE4y0e2VESNGdTrZB2Ma2cEyKc5LW0qHTnbhiW07vgfRCAgkk9Bo6IaR3CBAIpFc66YH0QpI//+7Mmy2z59ifbvaVeW3evHm7V5CJxL//XowsdzCQ9g93ui9HoXsNEy/H/XgFHsAr0T14FV6N1+C1eB2axOvRjXiDsdToRlPGMnQTep/Rg45Gx6D/oP+iaaPX6EPHol8by41+dBxyjBXGAPomPgIfiZ+Hj8JHo/uMdfgYdD8+1jjCOBIfh45HJ6B/GEcZR+PjjWPRicZxxvHo+cYJ6FvGiegB9CB6Dp+Avo1PNDYaJxuD6CRjCG3Ez0cnG7aRwicZGfQEGkRDRtbgeKNxCj4Z7XP9esg4FT2MB/EQtrCNU2gGp9F3ccYYxVnM8TA+Bb/AOM04HZ+K3m+cgW5GtyAb/R6lUNrYamzDL0QZ40z0FPqXsQO/CL8YvwRljbOM3XgE5xBH3zPORt9HsziPfoBHjVfgAh7Dm/BmvMWYMqYNx9hnzKBhdIoxa5SMc4w59AJ0KvqtUUafw6cZFXw6HsdnoBcaNfQLo240jKax3zhgHDQW0SgqGYfwVrwNb8dn4h1oDu/Eu/AEPgvvRmX8UnQO3mO83XgHqhjnoXl0qXE+KqAx9H/uAlaNdxrvQpvQb4x3GwbajBaM9xjvRTV8Nn4Zfjl+BX4lqhsX4L3oXPwq40LjIlzEk2gLOg3907jYuARPGZ9ApxuXGpehcfRD1DCuQPvRATyNmtgxrjauMa41rkNn4H3GDWgrnjFuRNuMm4yb8axxK3oSbUdnGrcZtxt34JJxJz4HHUQ70KJxF3o1nsNlPI8ruIpegxfQIXyu8WVcw3XcwE2837jbuAcfQJcZ96LXolvRTvQM2oUmjPuM+/FBdJbxAHoa/dt4EC+i84yH0G7jYeM7+BB+NXopep3xffQG9Eb8GvR6/FrjR/h1+PX4DfiN+E3GI8ajxmPG48YTaA8623jSeMp42vgFehl6Ofqd8Uv0Wfxm49f4Lfit+G3oFcbv0S+NZ4xnjT8YfzT+ZPzZ+IvxV+Nv+O34HcY/jefQJejj+Dx8Pn4nfhd+N34Pfi9+H34//gD+IP4QvgB/GH8EX4gvwh/FH8MX40vwx/En8KX4Mnw5vgJfia/CV+Nr8LX4Onw9vgF/Et+Ib8I341vwrfg2fDu+A38K34k/je/Cn8GfxZ/Dn8dfwF/EX8Jfxl/BX8Vfw1/H38B343vwN/G9+D58P/4WfgA/iL+NH8IP4+/g7+Lv4e/jH+Af4h/hH+Of4J/in+Gf40fwo/gx/Dh+Aj+Jn8JP41/gX+Jf4V/j3+Df4t/h3+Nn8LP4D/iP+E/4z/gv+K/4b/jv+B/4n/g5/C/8b/wf/H/4vwQRg5gkQZKkjWBCCCWMtJMO0km6yBKylHSTZaSH9JI+spz0kxVkgKwkq8hqsoasNd9nvt/8AFlnftD8kHmB+WHzI+aF5kXmR82PmRebl5gfNz9hXmpeZl5uXmFeaV5F1ptXm9eY15rXmdebN5ifNG80byIbzFvMW83bzNvNO8xPmXeanzbvMj9jfpYcYX7O/Lz5BfQx84vkSPPL5lfMr5pfM79ufsO827zH/KZ5r3mfeb/5LfMB80Hz2+ZD5sPkeagX9aHlqB+tQANoJVqFVqM15nfJUeRocgw5lhxHjicnkBPJ88lJ5iPmo+Zj5uPmE+aT5lPm0+YvzF+avzJ/bf7G/K35O/P35jPms+YfzD+SjeRkMkiGiEVskiJpkiFZ9Hn0F/RX9Dfzn+Zz5r/Mf6NlaClai9ahG1ASXYGORJejr6G3oy7CESbDqAe9GHWgTvRK9Cr0IvQScgp5Aeomp6Lb0O3khSiXSKCvo2+gO9Cn0J3o04kkug5dj76IvoTaUHuCJGiCJdoTHYnORFdiSWJpojuxLNGT6E30JZYn+hMrEgOJlYlVidWJNYm1iXWJ9YkNiSMSRyaelzgqcXTimMSxieMSxydOSJyYeH7ipMTGxMmJwcRQwkrYiVQincgksgmeGE6cknhB4tTECxMvSryYvAglyIvJS8gIyaG3kDz6AiKJMTJKCuhq9HcyRjaRzWRL4gxyGjmdjCfOJGeQrWQb2U7ORG8lO8hOsgt9mEyQsxIvJ7sTr0zsJS9FS9Cz6A/oLrQBvRcdgdajC9CH0AfRNaiIrkQj6AOJIrqY7CFno4+ii9BV5GXowoSDKLqbvJy8gryS7CWvIkUySabINHHIPjJDZkmJnEPmSJnMkwqpkgVyLqmROmmQJtlPDpCDZJEcIq8mryGvJa8jrydvIG8kbyJvJm8hbyVvI28n7yDnkfPJO8m7yLvJe8h7yfvI+8kHyAfJh8gF5MPkI+RCchH5KPkYuZhcQj5OPkEuJZeRy8kV5EpyFbmaXIM+Q64l15HryQ3kk+RGchO5mdxCbiW3kdvJHeRT5E7yaXIX+Qz5LPkc+Tz5Avki+RL5MvkK+Sr5Gvk6+Qa5m9xDvknuJfeR+8m3yAPkQfJt8hB5mHyHfJd8j3yf/ID8kPyI/Jj8hPyU/Iz8nDxCHiWPkcfJE+RJ8hR5mvyC/JL8ivya/Ib8lvyO/J48Q54lfyB/JH8ifyZ/IX8lfyN/J/8g/yTPkX+Rf5P/kP8j/6WIGtSkCZqkbRRTQilltJ120E7aRZfQpbSbLqM9tJf20eW0n66gA3QlXUVX0zV0LV1H19MN9Ah6JH0ePYoeTY+hx9Lj6PH0BHoifT49iW6kJ9NBOkQtatMUTdMMzVJOh+kp9AX0VPpC+iL6YvoSOkJzNE9HaYGO0U10M91CT6On03F6Bt1Kt9Ht9Ey6g+6ku+gEPYvupi+le+jZ9GX05fQV9JV0L30VLdJJOkWnqUP30Rk6S0v0HDpHy3SeVmgVPQ8x9A70NvROdD5dQO+i56I3J1+TfC3ai36F3kRr6Ku0nnwDbdAm3U8P0IN0kR6ir6avoa+lr6Ovp2+gb6Rvom+mb6FvpW+jb6fvoOfR8+k76bvou+l76Hvp++j76QeSlyYvS16evCJ5ZfKq5NXJa5LXJq9LXp+8IfnJ5I3Jm5I3J29J3pq8LXl78o7kp5J3Jj+dvCv5meRnk59Lfj75heQXk19Kfjn5leRXk19Lfj35jeTdyXuS30zem7wveX/yW8kHkg8mv518KPlw8jvJ7ya/l/x+8gfJHyZ/lPxx8ifJnyZ/lvx58pHko8nHko8nn0g+mXwq+TT9IP0QvYB+mH6EXkgvoh+lH6MX00vox+kn6KX0Mno5vYJeSa+iV9Nr6LX0Ono9vYF+kt5Ib6I301vorfQ2eju9g36K3kk/Te+in6GfpZ+jn6dfoF+kX6Jfpl+hX6Vfo1+n36B303voN+m99D56P/0WfYA+SL9NH6IP0+/Q79Lv0e/TH9Af0h/RH9Of0J/Sn9Gf00foo/Qx+jh9gj5Jn6JP01/QX9Jf0V/T39Df0t/R39Nn6LP0D/SP9E/0z/Qv9K/0b/Tv9B/0n/Q5+i/6b/of+n/0vwwxg5kswZKsjWFGGGWMtbMO1sm62BK2lHWzZayH9bI+tpz1sxVsgK1kq9hqtoatZevYeraBHcGOZM9jR7Gj2THsWHYcO56dwE5kz2cnsY3sZDbIhpjFbJZiaZZhWcbZMDuFvYCdyl7IXsRezF7CRliO5dkoK7AxtoltZlvYaex0Ns7OYFvZNradncl2sJ1sF5tgZ7Hd7KVsDzubvYy9nL2CvZLtZa9iRTbJptg0c9g+NsNmWYmdw+ZYmc2zCquyBXYuq7E6a7Am288OsINskR1ir2avYa9lr2OvZ29gb2RvYm9mb2FvZW9jb2fvYOex89k72bvYu9l72HvZ+9j72QfYB9mH2AXsw+wj7EJ2Efto2zNtz7KPsYvZJezj7BNtf2WXtv2dXcYub3uOXcGuZFeh96CfoTx6N3oU/Qg9jn6Kfo5+jH6CHkGPsavZNRhhg13LrmPXsxvYJzFhN2LGbsIduBN34SV4Ke5mN7NbcC/uwyOTNWe/0yGH4lSz4SyR19PVxqRTrh4A0kytuN9ZKq9nq9W54mTVn9Yolaed7pGpUm2qOb+v7BwUcnpDCCUszCQk9oUQvtgwl5DNRpSA9hGfi4zMF6dq1QoZqc5UK85c+0itVJkRqslIQYwd+UBQe96VUZyacioNPDpVdCe6Q61abOCCcAIXBLK7oLtRaOFGQXej0MqNguZGe8E3gRV8jwqBRwXwqCA9wgUxDW8SlnVsCsR1bpqqzs8Xpaz2Tb7Y5ObJYq1jc8BobjkNbxH+sS2+xi2Bxi2gcQto3CI0dpwWUnV6SBUeFzHB48KizvEQKTnuysdbJX2rpG8N0ROFygzb6mkuO/saeJswqnubHu1tLaK9TY/2tlbR3qYnzTbf4W0+V5t7Wau0i1ehsEtchjlrFaFkibj0J0qKEOxOabqJVmvOl4vNBtkGIdwmQ9ixrV4u1mdlHHbAIMOxIxzJnTJDd4YivTOyqE5tvliZnizX23ZOzR4oJne5S4t3CUl015QzXSqXi527wiIn5EJP+N5MBH5PCL8nAr8nIn5PBH5PRP2eCPyeiPg9AX5PSL/bJrzthydkyu6W3u0OvGO7p0tOzamX6ni3UNSxJ0TcoyzBewSxfU+Qo3ukIrxHij5biG4/20/67i0Cs/e0jeXqVHnr+OiSvEAIcPv46Uu2RsFtUXBnFDw7AuKirI/FUH0sRutjMVQfi1p9LIbqY1FP9WKLVC/qqV5slepFPdWL/kIWg7gVYYGKUB+LQX0sSlc6pkL1cSqoj9OyPjqyMDqyMDq6/U4L+x3dfqeV/Y5eGJ2gMPqBbQ/iSBxwxYEyJUPaVvc2Bp6R5XEmtJNmwjtpJiiPs155nA0YacmllZ16HZfk3in52ku+drN0DimBASUwoCQMoOfA9I5zQsrnQso752ZqjlMpuzu5NIXLshyUZTkoh6tn2auecmt2VIoL1XqjVl2YdXBF8lbCldRxK2nFr6RVWUmr+vJUWyxPVV+eaqvlqerpVfWjUg0qSlVUlGpQUaqRilINKko1WlGqQUWpRipKFYJchUpaDVXSGgwyHLVw2avLqNVDS1AP0dvK1cpMPdnwymdDls+GKp+NsJymTIGm70IzcLYpnG0GzjYjzjYDZ5tRZ5uBs82Is01wtgnlsynKZ1PWuAPSpQOhCnnAL58HZPlcDBEX/fK5KMvnYrB3FqF8LkrRh2T5PORvina52zcWy43ukqyk5/iVdCpaHCtRsBoF61HwUARsP7hxvllulBbKi92V5vxe+NtYLs0U+0IIHzngAc3KtFPbu1CsuXvITXZBaD+w1/0vLpOV+ep0cuSkqcW2nOO9niVeN3mveNM53tC5adZpLjSatYpHGRX0Ld5r+xZZtAWi6k04e1YAZ0tUSfCU6u4CNuSlz3560WM/XchvK5TF67x49ZQkt3mX2yWxJl7r3usuD5OccF/YhJLaVtjnvW4WAvNCP95VF8POWQ9Jd85OiQsyekiQO3ZW9zXqpRlPU8fmYm0arskep9b05o0Ls/BWOYweEloLXiQKXn7X6s60h9ni6d3jOdl2msdCdtWl+1ua4lVYNOqH0KtHcx6w1I3StFN3M8ddGRdecnoxAhYqYbBzwp1YLM3Mes72+IAvbcnmyOyl+ahwsnNWON+xveim0eycjIhX9cWKyMz2Lre5u7smHGuf8LFdYrVFAuY27egSCxVA+0JQ0pPXNin8l0s8I6I3I/2fCafQtKCXRAqVghQqiRSSa9R2SKJECpWCFCoFKSRcwXMyhRyRQo5IIUekkCesbUESRQo5IoUaYjG9BWJNP4UckUIiTnhKplBDplBdplBdpdA0pFA9lEKzoRRahBQqy9ypyGFappCIhBNOIZE8i+JVcJIGpFBJpFBJWDTthzBIoUNaCs1FU8iJplAznELNeArNRlNoSkuhOqTQQiiF6iqFSkEKVYMUagYptD+SQjMRaDoMLZGx9YmHIpBIBQX1BCkRQqnU8OcIU33IiWTvQoSzETFELr4PyiRQYLdKBoXoDSWDjwslReBCMwxN+jp27si1jZQXZovJnNMotm0quicqKSzUS+65mzzbRSUKLnrXrHuV3OIeOm71XFgouneS85PTRfOMprm1ab605N5GlbyYm9tLiR2z1badpZn5YmJXsUkmpKjE9tlSIu/+ba+X2oW+RrVSrXeCJgFQV5O4YJ4iSQe5EpgIMbdvm3dmgMljV+frUmBSMDu9WNq5OD9ZLbcVhZuTnpsznptuLSg3isQBZw95znrEhnC25Dk7J5wtS2crTfNgyW1zhEWJ2my1ve65ua9UKZbbxGWi4XrcBI8XXG+n3D8XbKt6xrKS71YpZPGyMCDJzZCjS5tRh/o0WM6ohuLUXvVD014MQu2EQ+2oUM+p8LBDTq260Xvp9F5KlX1OrVStdbjtjX/dOODjuxqzbmusoM59Va8DUkBpfzCnXjroz6m75afiQ45XCPxJLt6fJG2ZrlTnqateXri6xUW7UCwumacVrlyVks/VJ/mEMnkpNElGT428EjrcLqUmdIgLT4d3ATq8S6lDXnk6BJ+nQ/BJHeJS6hCMQod3JSJZby4EMQoAV5gCvBipaxkjHxJS/UmeYAUw12pBne0U1srreocnGK47hSwFOAen3ESerjYnyw51W8ta2ZV2zLzbS7s9rdudLbhr2/DuMSszZffesTg15zS8hnne7TKPlWw1T9T/4mv3ytHsonvrU+lya2TpkJtvxbJbmrtEK+g29m6Nnix3ndusNvzDqGum6bbzzrzT8MxY4kNCW4+UtlcOom1cGUGFKauiFPfmreiqEaSlgHNtEXBvC57VUVyE1g00735RIJaHEAG2H7BF935G3mUKdI8XJ8dzzzdglUAJH72medINhVuyZUMNUY3wrwFkyxk9Iiemw7FQKDnIwEVQYcpAlOKc2yyWBWFFlOD72QeIc5tuY1CqSpXLYtO7p6puydkrXmV8QojDoWPTA0SPREQWVqJ8ywbqjlsLBc6/knPlBtgrBxmQCCockGWKEkQijAnh+1QIwtN7fWTIRx8XCVrAGsjsL9Zd90r1ub3qQqDXx9BR+nIfHQ5Qr48VN+TS8SB/tNuzMMVPWrk7NAokqNQcooU8DmFDUR8IoSOhWBUiaAkeVhDEKTwhKDDSa+FsND7dEheKcwgRzjKJjmx/iQoi2B9ChNDrAjO8natbtSpE1kisWHFrYtkpFbtUULyHT3OkMllfcNehyyvXdcddLffkriUni7ONpPcghIl4eyFITrtTkk7TPcG9l6mm2xBX3BZ6punOqZTIbG1xf6VUTMyVFpLlYq2ULJdqxQ7vZVezNuc2tW3zxUqx0VYpuii84Cpz2yB3qLbVvDPDfV1wnA7xusVtP4oV9w7FOdcpu/c1lRkHN5oztdJc4kC1smSy6VbwRtXdEJ6tXdOl/aW6648IU4cb59L+Ytk1zVkRnBGed85BV5LH2O6eMN69WXmy4V82FnrK1ZnSVLHsxmkHHB2dHtW9mPLCldg2O89Klama4x1FbaIjancb9VnvGU2x7DZmI7Va9UC7qKDikk1XD1TklZfK4mqJd7XDZ+loLowqpqXyerJYdwTcW64ecGrbKk5BHLE5t5+e61O4M92ou7YJZL9A7vKOaclaF+glAr25WN4nwOUCHHPP7zDTimAuiKyHZO70TvgwO9vnxl5Kby4shKT3CjBqbI/naxTVC6iw+cs9XMx6ETLw2b3S7e73J0XMFrJiVss1kQaIy6hRMlDjSt9SAe7wp0hPffKxPjhSmR5XM9V1MG11jC+gRWRMeNcyJUICBd9x/5svELi06RNDyv+X0BgtLrS97t09lz24Q1zKNo2J6+liba5jsuwW6nypNlV2Og7MlhoOXLv7fwauB7wVkWni8u4OmFaKlWhJCSWuRgklXZTSG1EjcX1RDRK5PBypgNUPdEjmGh/p5ti0W+QiRD9pWhDXBinUihqY0ILa49aehleIxtxGVaI6p6uNhjMtAbLPraXOokO9Mlh3L2Tkc6IodpUqonRJqAegkPTVfgS3xGl+3OO0Tn/eSG2q02f0gCBHa1NdodxyoSAM/ixg7BSpM1oqzrv3mp3CAwD6IisJyOXRpQRsr3sI6Lj+STdW1fkYq9C3pbI7pKlH4La7x5cbLLf614rzPcKSCGqZ4DoLFmWHexi07/NuIaa9Syb4vatl4irMJnfHTvfcr8EayeuVck7VO6Gn8+69jRtqSZHat1RywURYegn0BQealxwwKZwvwOceTXV3lzamZgPkerE0XnAbVbESIqQ6XSCBQdZdRV/jnsnipGslvFv6Ol/0EdLhABHdoGBndFUlcoOfT6OgUGM4Isiqw3BsUCHJlcThXZkZd8//3cESrBHWTejbO0wc17e3JK4NiJENHKZOxLa3pC6T9TNkB2BCpveHeYLo9YcZA7Rb9gVqV60k7pd7an5dU6hlXhMSxciTNYRxxQiFUTERlBATxZRVtVSYfk3M7lJjdrTaWNFcGA+vvSIPNBd2RNbflxx4sb0qWrBu32RALAssDLOEEX0QGxEuJXpFIDqC7/ejFEX7eiPoPnC0heg4vt+PXFx0Cyna8eTjw01JCN8f6l3C6FDPEs6PQLqPCgQHK6tk+hhfnMKsmqweHBUPe0T/Wpne7JemPp3kzVuuI4XGXh8bTB/wcRMLEbk9UYIntTeKEjKX+ThVjNfFMBG5A63InvSVrQhCxwZBOVCR1Ii0naUgPCEGT54krdZJQqKkrQPaZqe4fzEidtxjGtDInlBBWNWCMLEgSCs1ktAmKKtbUWDWBo02saCZoiwdhzYyIIspAxpZFACPsKoFwRXukVZqJFkcPMrqVhSYtUGjhS2NMMgIR0yVS7BKZxBnjyCt1kny1BG0NS5NKIC0dm8+A8mr4kSVQ50B6UBlZRiI2NarUTyj+jScsKZHIYO5vgqVxT7gCfImiZnrFUUcU80F3Ym1LenKjy5FFbL8aLgFIiZoVZyopLQr0sTCiuAyEollEbznRX8UI9fkQKUnghZmdSuU0rdWR0RUrWhB9RQOtMD7IZTp0nofrQV6hOan6+pWVJh5RCuaUh+RHdkVviGrW1FhzxzRiqZkCw7lF0yIWe6twDj09aEEXRFHi3l9Iby/ist1pGD1saq3y3vt5tE61u/ddlWDZqw1lzzbqn5Dt8bnOszG1Yjhjevn2sowENu4YYrauGGcv3EFMrpxBUptXB/wVPibbb2i/I+NG6eHN25QBPxoHG7jasTwxh2XOdUfXCozPT9XRNGR/RzgPed6Ihh/446H03KtjohtXJ2qNq6O90MY3TDRY3OtoodpkY0bo4Y2bowW27jBMRyS7W/cGDW0cWO02MYNb3Xdcu/cnlg4bN8yECUHXcvKKCHUs2wQFKVMuBFtFdZEGDTiqggxYmp/jOTH/nBlaUWc5rczsDwxGwX3mgiDRlwVIUYWqz9G8tcwQEfzbEWcJvByZQ7bpQxEyUGPsjJKCHUoR7kUlRyHXfF1rZiCdV/fihxa/SND9MMs8ZoWLP5qrm1BDNYtLP0wi7OmBYu/DmtbEIOIh+Nz2Liva8UURH99K3JoDTaot6F3eJ/OcKbHytWasLzWkM/o2vY7lWY9OV+s1ZfUF4rTjrzdbJYaXVPl5qQPLZkVcxTYPS2fYfkINjXrTM25YuYGaodRxRZci7yHh9N4qlhzqvvwfKnifXC27ky5oljZvRmt7SzNVHClOe/Uqsx7n2jeEyWf1m12DnrHar8E/DgVyuXSQh0eAY0HT35DCHhSJRBniCcZ8AhuXRjl7hB1e5l3Ko2aEyGH7z6BHBY4Xj3kvU+0PoSK3NTClDUh+sSCRuySDwRdwPNzWfBMC6wNYUBdX+ThIETCRy7Wg0c1y7XnkjJG/cETvVwoxH3+A9bQw6IB/7ZcI/SEH4PCQ2RAhbhWuCj/eUsILx++qrWVQGxt5VOv0FIKRGQpwyiITpd8mqriGTwSVNGLPDNV0VPIcPQGivNuJ1cvVqb3+lfy/XnvbdDQ5xJ6PTj47IN8d1fh1OcbBLZTYOHjDwMAiL/wO7M9Chl6S74V35IoT7dO752ulsv6nIVys77Xe5EsPhjglgkwPKlfvp2sf3RhBbzLrH+uoFt/97k/hAihB8LoSADiqFURVITUJ0nap1YkUn97vFcJCC3f6iguaomihT50oVChN+0jqKhxrSxerSEjH/jRaYGaNTop8na+8D8kaEUIEcYPhPFhCcvDBD+QSwU2cH+dgGHN49J7BDnyGYVVEVREZZcgqQ2xTEE+ZnkY0wIbD4BM+ZCjrfaAIPj53u+D0U/hSEf96C8P4BB2rY6NyFgRokayIoT3Iy3djxsafD7LB8MR7wuwoTwPkMEHnGAdIh/jWqMhI/rX60RtsgxR8FGRFQEcrR8hEeFcCUtuqM/7+KhQoTmMfasOb5pUKb+REq6jbh33vmOyF0ZZlb2PqZw036zLO9VysTJ3klu6vTfcuqarjfqQgpYIyFLgUgnaCu4GOKUQyxQirTA9PiajUL0BKqtwfSEcb8HI4/KycbZsCzYesy0TY8rEZWVayMrEZWVjTNk4E9fjldZZ0jGb0nGb0i1sSsdtSsdsSsdtSsdsyugsmZicTFxOJiYnq7NkYyxcy6eUxpDS45OKxScVj0+qRXxS8fikYvFJxeOTisUnpccnFYtPKh6fVCw+KT0+qVh8Unp80hpDWrclHbMlHbclHbMlrduSjtmS1m3JaAwZXUYmJiOjy8hqDFmdwYdl/bGjZFvLF1vPFzuWL3Y8X+wW+WLH88WO5Ysdzxc7li+2ni92LF/seL7YsXyx9XyxY/li6/lia/li6/lix/LFjueLHcsXW88XO5Yvtp4vtpYvtp4vdixfbD1fbC1fbD1fbC1fUlFySotHSo9HKhaPVDweqVg8Uno8UrF4pPR4pLR4pPR4pGLxSOnxSGnxSOnxSGnxSEfJac2GtG5DOmZDWrchrdmQ1m1IazZkouSMNj+jz89o87NRclYj+6DoX6wI0YrWD0urH5ZeP6xY/bDi9cNqUT+seP2wYvXDitcPK1Y/LL1+WLH6YcXrhxWrH5ZeP6xY/bD0+mFp9cPS64cVqx9WvH5Ysfph6fXDitUPS68fllY/LL1+WLH6Yen1w9Lqh6XXD0urH1a0flha/bD0+mHF6ocVrx9WrH5Yev2wYvXD0uuHpdUPS68fVqx+WHr9sLT6Yen1w9LqhxWtH5ZWPyy9flix+mHp9cPS6oel1w9Lqx9WtH5YWv2w9PphafXDitYPS6sfVrR+2BGiHc0HW8sHW88HO5YPdjwf7Fg+2Ho+2LF8sPV8sLV8sPV8sGP5YOv5YGv5YOv5YGv5YEfzwdbywdbzwY7lg63ng63lg63ng63lgx3NB1vLB1vPB1vLBzuaD7aWD3Y0H1IRYirqf0rzP6X7n4r5n9L9T2n+p3T/U5r/qaj/Kc3/lO5/SvM/FfU/pfmfivqfjhDTUd1pTXda153WdKejutOa7nRUdyZCzETnZrS5mejcbISYjRIDSLwRUyyfJL6rIz+qF0F1Bb8GM1+dXiJ+scT7LQJn2gW795Vq9UajWnGmZsW3ezrVt3pdvklPk/yRDw9i4hvm4kr8Mod31R3+TRIPsST4VRHBKX4bRFyJX0fxrqj3SyUCJZ7/eFft8gvzQqf/yyMe1Bcy10dS7zdRvAvvk8/iZ0s8YGnot1g8uAN+pEXIlz+S4l0uCzu4capYF0UumCZQS3xXJej7K8DlutMC2xv1XE703ZegHwMBdqlASKIfDQEuDUIirYzERc5XcRDQgHywFn/stiywHn5LpT/qj0K3yW9si1epIPoVb9/6k6YWl4UBwZwY37KJNCulwcHBYW8cKowU5JjLwDgIowVjCvjUmIcR+Ec4jCMwwvwRNR/k54E/D/Q80PMgNwdyciAnJ/QMDlmKD/B5LvF2BsacHFNpOQ6PSr5R0DMKckdBzijoG1X2gD95sHMU9BQUP9BHgV4YlHoKI3JMSzusIdAzXJB4PibHjAV0JRf0F0B/AeaNgb0FxQd6C6B3DOaNgT4b7BtT8R+DuGVhHILRhjENfGqEOI0A/4jKhxyMMH9EzQf5eeDPAz0P9DzIzYGcHMjJjUp708Ownoof6Plh8CcL66lGWP8U+JtV6wF6R0HPKMgbBf2jyj7wLw92j4K+guJXeQL0whCsK+RTOgvrBnZnbICVHNBXAH0FsGcM7CsoPtBTAD1jMG8M5Ntgz9hwnzuOZLMp9SffcNGQPsGbZQ1mZZalhgZhHILRglFanRqEcVjxpWBMAx3wg2p+BsYsjBzGYeAbBXgE4DzAORgVrPgKMIK9FuizQJ8F9lrKXuC3wE4L7LTAHgvss8AuS9ml5IN+C+yzwK5BxafsVv4rPWDvIMgfBH2DoGcQ5FjKPtA3CPYPqxHmD4OeEcCPwLwc+J8DfA74c8CfB/oo6C0AX0HBhaWwjurHWgDORWHLp8t5Nsi1Ie42yLUh7mmVJ4oOcbEhTmmYn1Z0sBt2bcoG+2yIcxriaYNfaVgXqNopW8GKD+JjQ1xToC8F+lJgb0rZC/wpsBNOgVQK7IHqkUqBXSlll5IP+lNgXwrsSis+ZbfyX+kBe6H6p6BauD00jCAnpewDfWmVHyrOMG8Y+EcAPwL8OfA7B/gc8OeAPw98o2BvAfgKCh5bCusczQvb1mAtj+yMBmc1mGvwcBROj2r0EQ3W8tQei8Ipzd6UZk9K05/S9KfyGqzpTxU0/UPqZ45E3Oxhuc62PBUHbYizDV2JLbuXQVueNtYgH4RxCEYLRhvGFIxpGDMwqvkcxmE5ZmXeD8rT1B0tGEFeFuRlQV4W5GVBXhbkZYcZ/KDLZFli5A6zspk8jDKTB2U/YA3CiWBnC4AHz6DSFuTOtAZz6S7xAYZ5t2dvFGuLyUKzVpUkNSUHQciBsUqFbAndcQTGPNDBiRwEMQf8I+BMDoIzouYBfgTkycWy4Mh2Rxkce2Ssy+2Dg58FENgheYRYFpR61yFS9L6u31xoF6P4hBETl943v+SV92UveTVZbcwymDBd6fSvJuuOkJuGVEhDKqTdVHCp3vexAU7DmIEx2wbUhRCXTESXOgZjAcZRUt4XlpaDcQTGYVJrhOWAtmHQJguPO3IYh2GE+cMgbzgP4yiMoH94jJQb4gvkbeKVTM/JUVDzY3hKfslZgAUwXvbk7gihGYXQyB7OHcE42FXpUXB+FIwfA3hMwcA/Bvx5MDIPRufBqXyhvbrgVOTvTbBSZX9wFTZzFHwfBd8LYG5BmQtiR0HNKMRiFNzLgzmyRbZysolyRwVzGJVZEPsc6IG8T48U4JvJNWeqAShQOTLGJGmyehAwahLEUp4grhJwZgRiNgIxg02WHoGYweZKw+ZJj6h5KgjAVwC+AvAVgK8AfGPgxBjYMwb2jMHajik+COIYeDRWII1aqTjTXIAgZCQ8XYEgqeCAnBzYk1NrDfoKILcA+ALIrTXkWN4H88COPMQDilM6pxYDFjUP9ucUH/idU4sN9hSAXgD+gsKrXIV5YzBvDOI2BvoysB5p8CsN89Lgdwbmp8GvNMxPg99Qx9MZ0JtR88CutJIPdBvoQ2CvBXoHwe8hsDMF8i2AhxQM9gyCPRbgUyAno+xX+kFPCvhTIC8L62CDXUMwDgJ9EOTCSZbOgn2DSj/Mz0I8BkHfINiRBT4b+IYUv/JH+Q16U0C31KjwINcC+22AbQWDfzbYkVKjWg+wOwP8GeU/rEMW+LIgJ6viCeuagvlwsqctwA/B/EGAB5U8iH9W4SF+g2AXdArpQeAbBBg6iXRW+QV0KFrpIcWv/AX5luJT9oI8C+y2AbYVDP7ZsD4pNYKcDOhLg7y0ooN/NtDh+E6rOjek8hfwKeCzVdwUH8izwA9oEtIZtf9g/dNqfwKcAf602h9q/yh7lH1At0DukFp30J8B/+Wdi5UZGsb7nPli2Ul6L23iqwNJ7xsDbeKLAgS+HyCYs7BJsmDsECTxECT/ENCH1MkDTuYgaXKwWDnYDDkwMgcnV06dXFAUcnBC5aBY5qA45KAI5CCoOVjsHDibyyv56jACOyCJcnmYN6ToIB+KSQ42W25I2a38AXsg2DlL6QG7hgod8JFD7+OHAsdhY3AoKBw2PIdCwaHgcPCNwwJyKBQcCjeHws8hATic+nwYRrCBwwbn0PTwERih8PE8jFzpBTsgUTlsdA5NDYcDj8MBwaE54tDBcVgrDjnB4cDmcMBzKMwc1pZz5XcO9MMIhZJDYeZwYHM4MDlsDA7dEYcOkcMacNgoHBoCDg0Eh8LKISc4V3phHeAA4FAIOTQMHA58DgcXhyaRD8MIucXh4ONw8HJogDgUYA4HNedq3dMwjoIdMEJB51AAOTQoHBoNDgcwh+6PQ0fMIVc5FHgODQiHlo3DwcehOeVc6QU74EDhUIA5NLccGg8OBymHJphDJ89h73I46Dk0IhwaPQ4HF4e9y7nyexj0wwiFmMOByaFh4dDwcCjAfBRGuFPgUAM4NCgcGkMOjSSHws6hCedc6YV9CAcBhwOPQ+PIoQvm0OBwuFngwzBCjeBQSDl05xwaYQ6NC4fGkHO17y0YMzAWwB4Y4YDi0GjwMRihIeRQsDl0/RzuhDjUPg4HPS/ACHelHA5wnoeRK71gBxyQHA5mDjc1PAcjNHAcbo443MFxqIkcGkhegBEafA4HMYfazrnyewT0wwiNC4dGikODyuHunEPDyeHuiMMdIofaz+Fg43BDwOEGgkMjxKHWc670wjpA48Sh8eFww8DhqQGHxpHDTSIfhhHONA4HMofGm8MNEIeDmUMDz7la9xSMebADRmhkODRMHG5QODyV4NCIcLj743BHzOFM5dCAc7gB4SMwQgPH4WaUc6UX7IAGi0PDxuHmlsMNCYcbAQ43wRyeBHA4wzk02hxuNDjc6HFopHgeRq785qAfRmikODTYHG5IONwIcWiA+CiM8KSAwxnMoVHjcGPI4UaSQ+PFoXfgXOmFcxhuQDg0wBxuHDncBXO48eHwsIAPwwhnPocbHA535xyeNnFoEDncMHL5SG7QzsKjPFlfBy14hGfBI1QL3oCy4RG/DY/8bXjUb8OjfRve4rDheZENbyHY8NaBDW+52PAWiA1vUdjwloVt8U7QI96JBSAbBnJhwAoD+TCQCQMjYSAVAoaktA7/PeCpxe7QtSD+PzXnEgl4nG2KaVOSYRSG3xcEyczMCnlluUFBhCcU4QkEocilRSpEfJAHbLOF9oX2/a2ZZvyi4ww/wy/Qp/oRfOgXnWAGm2qcM3Of61znztDXU4Qv6Sr0NOFzivApWcfHJOHDLOF9MoF3CcLbmTrezBBexwiv4rt4GSe8OEl4HkmjFtHxLEJ4GiU84YTH4RoehQkPwy08mCbcnyLcm2rh7mQd1UnCnUkdt0M6boUIN9t7I1TEjRBw/QThGiviKiNcYTWsBwiVIKEc1CEDUyhNENb8LRT9BOEjrI4TCr40Vrw68l7CsreInJfjsteNS2OEi6N1ZEcJSx7CBU8O5z0hnPO4cNZNWHRzLLgI86DML8xBxxknIeMgnHboSKeqSCWXMJusYSZWRzzGwaM5RCOLmA7nwAIcwYCOgNOurU/Yh+DXRrT18ZZP+Ext8GqEMe0YRj06PFaC22YFdl3CNUxwVh3C0XZ2rmkVW8q6URnp0HCHjmsL1rXyUT4kjvBBMSQH5SHeL0y8R/TLHnk4MSAO8j7Ry81C5YoYkH3SLBV5gFuEkRuERRrkoGLMZEzqT3VHWWXZH720km1YlisNdbPhK3Qyky83zJsNRZQrpaaqbstvW1uKcy7b2CmUvhuVNsqmwTCfLzV7jNtyTmEKY0zpDuvyXqp/Tfet7rU7xP7xXWJ/7v/UPnLfFrP9BvOls3wAAA==") format("woff2");}';class Random{constructor(e){this.seed=e}next(){return this.seed?(2**31-1&(this.seed=Math.imul(48271,this.seed)))/2**31:Math.random()}}var commonjsGlobal="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},lzStringExports={},lzString={get exports(){return lzStringExports},set exports(e){lzStringExports=e}};function splitFolderAndFilename(e){const t=e.lastIndexOf("/"),A=-1==t?e:e.substring(t+1);return{folderpath:obsidian_module.normalizePath(e.substring(0,t)),filename:A,basename:A.replace(/\.[^/.]+$/,"")}}!function(e){var t=function(){var e=String.fromCharCode,t="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",A="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$",i={};function n(e,t){if(!i[e]){i[e]={};for(var A=0;A>>8,A[2*i+1]=r%256}return A},decompressFromUint8Array:function(t){if(null==t)return a.decompress(t);for(var A=new Array(t.length/2),i=0,n=A.length;i>=1}else{for(n=1,i=0;i>=1}0==--d&&(d=Math.pow(2,u),u++),delete s[c]}else for(n=r[c],i=0;i>=1;0==--d&&(d=Math.pow(2,u),u++),r[l]=h++,c=String(o)}if(""!==c){if(Object.prototype.hasOwnProperty.call(s,c)){if(c.charCodeAt(0)<256){for(i=0;i>=1}else{for(n=1,i=0;i>=1}0==--d&&(d=Math.pow(2,u),u++),delete s[c]}else for(n=r[c],i=0;i>=1;0==--d&&(d=Math.pow(2,u),u++)}for(n=2,i=0;i>=1;for(;;){if(p<<=1,m==t-1){g.push(A(p));break}m++}return g.join("")},decompress:function(e){return null==e?"":""==e?null:a._decompress(e.length,32768,(function(t){return e.charCodeAt(t)}))},_decompress:function(t,A,i){var n,a,r,s,o,l,c,d=[],h=4,u=4,g=3,p="",m=[],w={val:i(0),position:A,index:1};for(n=0;n<3;n+=1)d[n]=n;for(r=0,o=Math.pow(2,2),l=1;l!=o;)s=w.val&w.position,w.position>>=1,0==w.position&&(w.position=A,w.val=i(w.index++)),r|=(s>0?1:0)*l,l<<=1;switch(r){case 0:for(r=0,o=Math.pow(2,8),l=1;l!=o;)s=w.val&w.position,w.position>>=1,0==w.position&&(w.position=A,w.val=i(w.index++)),r|=(s>0?1:0)*l,l<<=1;c=e(r);break;case 1:for(r=0,o=Math.pow(2,16),l=1;l!=o;)s=w.val&w.position,w.position>>=1,0==w.position&&(w.position=A,w.val=i(w.index++)),r|=(s>0?1:0)*l,l<<=1;c=e(r);break;case 2:return""}for(d[3]=c,a=c,m.push(c);;){if(w.index>t)return"";for(r=0,o=Math.pow(2,g),l=1;l!=o;)s=w.val&w.position,w.position>>=1,0==w.position&&(w.position=A,w.val=i(w.index++)),r|=(s>0?1:0)*l,l<<=1;switch(c=r){case 0:for(r=0,o=Math.pow(2,8),l=1;l!=o;)s=w.val&w.position,w.position>>=1,0==w.position&&(w.position=A,w.val=i(w.index++)),r|=(s>0?1:0)*l,l<<=1;d[u++]=e(r),c=u-1,h--;break;case 1:for(r=0,o=Math.pow(2,16),l=1;l!=o;)s=w.val&w.position,w.position>>=1,0==w.position&&(w.position=A,w.val=i(w.index++)),r|=(s>0?1:0)*l,l<<=1;d[u++]=e(r),c=u-1,h--;break;case 2:return m.join("")}if(0==h&&(h=Math.pow(2,g),g++),d[c])p=d[c];else{if(c!==u)return null;p=a+a.charAt(0)}m.push(p),d[u++]=a+p.charAt(0),a=p,0==--h&&(h=Math.pow(2,g),g++)}}};return a}();null!=e&&(e.exports=t)}(lzString);const download=(e,t,A)=>{const i=document.createElement("a");i.setAttribute("href",(e?`${e},`:"")+t),i.setAttribute("download",A),i.style.display="none",document.body.appendChild(i),i.click(),document.body.removeChild(i)};function getIMGFilename(e,t){return`${e.substring(0,e.lastIndexOf("."))}.${t}`}function getNewUniqueFilepath(e,t,A){let i=obsidian_module.normalizePath(`${A}/${t}`),n=e.getAbstractFileByPath(i),a=0;const r=t.endsWith(".excalidraw.md")?".excalidraw.md":t.slice(t.lastIndexOf("."));for(;n;)i=obsidian_module.normalizePath(`${A}/${t.slice(0,t.lastIndexOf(r))}_${a}${r}`),a++,n=e.getAbstractFileByPath(i);return i}function getDrawingFilename(e){return e.drawingFilenamePrefix+(""!==e.drawingFilenameDateTime?window.moment().format(e.drawingFilenameDateTime):"")+(e.compatibilityMode?".excalidraw":e.useExcalidrawExtension?".excalidraw.md":".md")}function getEmbedFilename(e,t){return((t.drawingEmbedPrefixWithFilename?e:"")+t.drawingFilnameEmbedPostfix+(""!==t.drawingFilenameDateTime?window.moment().format(t.drawingFilenameDateTime):"")+(t.compatibilityMode?".excalidraw":t.useExcalidrawExtension?".excalidraw.md":".md")).trim()}async function checkAndCreateFolder(e){const t=app.vault;e=obsidian_module.normalizePath(e);const A=t.getAbstractFileByPathInsensitive(e);A&&A instanceof obsidian_module.TFolder||(A&&A instanceof obsidian_module.TFile&&new obsidian_module.Notice(`The folder cannot be created because it already exists as a file: ${e}.`),await t.createFolder(e))}const getURLImageExtension=e=>{const t=e.split("?")[0];return t.substring(t.lastIndexOf(".")+1)},getMimeType=e=>{switch(e){case"png":return"image/png";case"jpeg":case"jpg":return"image/jpeg";case"gif":return"image/gif";case"webp":return"image/webp";case"bmp":return"image/bmp";case"ico":return"image/x-icon";case"svg":case"md":return"image/svg+xml";default:return"application/octet-stream"}},getFileFromURL=async(e,t,A=3e3)=>{try{const t=await Promise.race([fetch(e),new Promise((e=>setTimeout((()=>e(null)),A)))]);if(!t)throw new obsidian_module.Notice(`URL did not load within the timeout period of ${A}ms.\n\nTry force-saving again in a few seconds.\n\n${e}`,8e3),new Error(`URL did not load within the timeout period of ${A}ms`);const i=await t.arrayBuffer();return{status:t.status,headers:Object.fromEntries(t.headers.entries()),arrayBuffer:i,json:null,text:null}}catch(t){return void errorlog({where:getFileFromURL,message:t.message,url:e})}},getFileFromURLFallback=async(e,t,A=3e3)=>{try{return await Promise.race([(async()=>new Promise((e=>setTimeout((()=>e(null)),A))))(),obsidian_module.requestUrl({url:e,method:"get",contentType:t,throw:!1})])}catch(t){return void errorlog({where:getFileFromURL,message:`URL did not load within timeout period of ${A}ms`,url:e})}},getDataURLFromURL=async(e,t,A=3e3)=>{let i=await getFileFromURL(e,t,A);return i&&200!==i.status&&(i=await getFileFromURLFallback(e,t,A)),i&&200===i.status?await getDataURL(i.arrayBuffer,t):e},blobToBase64=async e=>{const t=await e.arrayBuffer(),A=new Uint8Array(t);for(var i="",n=A.byteLength,a=0;a(void 0===window.pdfjsLib&&await obsidian_module.loadPdfJs(),await window.pdfjsLib.getDocument(app.vault.getResourcePath(e)).promise),labelCTRL=()=>DEVICE.isIOS||DEVICE.isMacOS?"CMD":"CTRL",labelALT=()=>DEVICE.isIOS||DEVICE.isMacOS?"OPT":"ALT",labelMETA=()=>DEVICE.isIOS||DEVICE.isMacOS?"CTRL":DEVICE.isWindows?"WIN":"META",labelSHIFT=()=>"SHIFT",isCTRL=e=>DEVICE.isIOS||DEVICE.isMacOS?e.metaKey:e.ctrlKey,isALT=e=>e.altKey,isMETA=e=>DEVICE.isIOS||DEVICE.isMacOS?e.ctrlKey:e.metaKey,isSHIFT=e=>e.shiftKey,setCTRL=(e,t)=>(DEVICE.isIOS||DEVICE.isMacOS?e.metaKey=t:e.ctrlKey=t,e),setALT=(e,t)=>(e.altKey=t,e),setMETA=(e,t)=>(DEVICE.isIOS||DEVICE.isMacOS?e.ctrlKey=t:e.metaKey=t,e),setSHIFT=(e,t)=>(e.shiftKey=t,e),mdPropModifier=e=>!isSHIFT(e)&&isCTRL(e)&&!isALT(e)&&isMETA(e),scaleToFullsizeModifier=e=>isSHIFT(e)&&!isCTRL(e)&&!isALT(e)&&isMETA(e)||!isSHIFT(e)&&isCTRL(e)&&isALT(e)&&!isMETA(e),linkClickModifierType=e=>isCTRL(e)&&!isALT(e)&&isSHIFT(e)&&!isMETA(e)?"active-pane":!isCTRL(e)||isALT(e)||isSHIFT(e)||isMETA(e)?isCTRL(e)&&isALT(e)&&!isSHIFT(e)&&!isMETA(e)?"new-pane":DEVICE.isDesktop&&isCTRL(e)&&isALT(e)&&isSHIFT(e)&&!isMETA(e)?"popout-window":isCTRL(e)&&isALT(e)&&isSHIFT(e)&&!isMETA(e)?"new-tab":mdPropModifier(e)?"md-properties":"active-pane":"new-tab",externalDragModifierType=e=>DEVICE.isWindows&&isSHIFT(e)&&isCTRL(e)&&!isALT(e)&&!isMETA(e)?"embeddable":!DEVICE.isMacOS||isSHIFT(e)||isCTRL(e)||!isALT(e)||isMETA(e)?!DEVICE.isWindows||isSHIFT(e)||!isCTRL(e)||isALT(e)||isMETA(e)?DEVICE.isMacOS&&isSHIFT(e)&&!isCTRL(e)&&isALT(e)&&!isMETA(e)?"insert-link":isSHIFT(e)&&!isCTRL(e)&&!isALT(e)&&!isMETA(e)||DEVICE.isWindows&&!isSHIFT(e)&&!isCTRL(e)&&isALT(e)&&!isMETA(e)?"image-import":"image-url":"insert-link":"embeddable",internalDragModifierType=e=>(DEVICE.isIOS||DEVICE.isMacOS||!isSHIFT(e)||!isCTRL(e)||isALT(e)||isMETA(e))&&(!DEVICE.isIOS&&!DEVICE.isMacOS||isSHIFT(e)||isCTRL(e)||isALT(e)||!isMETA(e))?(!isSHIFT(e)||isCTRL(e)||isALT(e)||isMETA(e))&&(isSHIFT(e)||!isCTRL(e)||isALT(e)||isMETA(e))?scaleToFullsizeModifier(e)?"image-fullsize":"link":"image":"embeddable",emulateCTRLClickForLinks=e=>({shiftKey:e.shiftKey,ctrlKey:e.ctrlKey||!(DEVICE.isIOS||DEVICE.isMacOS),metaKey:e.metaKey||DEVICE.isIOS||DEVICE.isMacOS,altKey:e.altKey}),emulateKeysForLinkClick=e=>{const t={shiftKey:!1,ctrlKey:!1,metaKey:!1,altKey:!1};if(!e)return t;switch(e){case"active-pane":setCTRL(t,!0),setSHIFT(t,!0);break;case"new-pane":setCTRL(t,!0),setALT(t,!0);break;case"popout-window":setCTRL(t,!0),setALT(t,!0),setSHIFT(t,!0);break;case"new-tab":setCTRL(t,!0);break;case"md-properties":setCTRL(t,!0),setMETA(t,!0)}return t},anyModifierKeysPressed=e=>e.shiftKey||e.ctrlKey||e.metaKey||e.altKey,getParentOfClass=(e,t)=>{var A;let i=e.parentElement;for(;i&&!(i instanceof window.HTMLBodyElement)&&!i.classList.contains(t);)i=i.parentElement;return(null===(A=null==i?void 0:i.classList)||void 0===A?void 0:A.contains(t))?i:null},getLeaf=(e,t,A)=>{switch(linkClickModifierType(A)){case"active-pane":return t;case"new-tab":default:return(()=>{if(!e.settings.openInMainWorkspace)return app.workspace.getLeaf("tab");const[A,i]=getLeafLoc(t);return"main"===A?app.workspace.getLeaf("tab"):getNewOrAdjacentLeaf(e,t)})();case"new-pane":return getNewOrAdjacentLeaf(e,t);case"popout-window":return app.workspace.openPopoutLeaf()}},getLeafLoc=e=>{const t=e.id,A=app.workspace.getLayout(),i=e=>e.children.filter((e=>"leaf"!==e.type)).map((e=>i(e))).flat().concat(e.children.filter((e=>"leaf"===e.type)).map((e=>e.id))),n=i(A.main);return[A.main&&n.contains(t)?"main":A.floating&&i(A.floating).contains(t)?"popout":A.left&&i(A.left).contains(t)?"left":A.right&&i(A.right).contains(t)?"right":"hover",n]},getNewOrAdjacentLeaf=(e,t)=>{const[A,i]=getLeafLoc(t),n=e=>{var A;let n=app.workspace.getMostRecentLeaf();return n&&n!==t&&(null===(A=n.view)||void 0===A?void 0:A.containerEl.ownerDocument)===document||(n=null,i.forEach((A=>{var i;const a=app.workspace.getLeafById(A);n||!(null===(i=a.view)||void 0===i?void 0:i.navigation)||t===a||e&&(null==a?void 0:a.parent)===(null==t?void 0:t.parent)||(n=a)}))),n};if(e.settings.openInMainWorkspace||["main","left","right"].contains(A)){if(!e.settings.openInAdjacentPane){if("main"===A)return app.workspace.createLeafBySplit(t);const e=n();return e?"empty"===e.view.getViewType()?e:app.workspace.createLeafBySplit(e):app.workspace.getLeaf(!0)}const i=n(!0);return null!=i?i:app.workspace.createLeafBySplit(t)}if(!e.settings.openInAdjacentPane)return app.workspace.createLeafBySplit(t);if("hover"===A){const A=new Set;return app.workspace.iterateAllLeaves((e=>{e!==t&&t.containerEl.parentElement===e.containerEl.parentElement&&A.add(e)})),0===A.size?e.app.workspace.createLeafBySplit(t):Array.from(A)[0]}if("popout"===A){const e=new Set;return app.workspace.iterateAllLeaves((A=>{A!==t&&A.view.navigation&&A.view.containerEl.ownerDocument===t.view.containerEl.ownerDocument&&e.add(A)})),0===e.size?app.workspace.createLeafBySplit(t):Array.from(e)[0]}return e.app.workspace.createLeafBySplit(t)},getAttachmentsFolderAndFilePath=async(e,t,A)=>{let i=e.vault.getConfig("attachmentFolderPath");if(i&&i.startsWith("./")){const e=`${splitFolderAndFilename(t).folderpath}/`;i=obsidian_module.normalizePath(e+i.substring(2))}return i&&"/"!==i||(i=""),await checkAndCreateFolder(i),{folder:i,filepath:obsidian_module.normalizePath(""===i?A:`${i}/${A}`)}},isObsidianThemeDark=()=>document.body.classList.contains("theme-dark"),getContainerForDocument=e=>{if(e!==document&&app.workspace.floatingSplit)for(const t of app.workspace.floatingSplit.children)if(t.doc===e)return t;return app.workspace.rootSplit},useDefaultExcalidrawFrame=e=>!e.link.startsWith("["),patchMobileView=e=>{if(DEVICE.isDesktop)return;console.log("patching mobile view");const t=getParentOfClass(e.containerEl,"mod-top");t&&(t.hasClass("mod-visible")||t.addClass("mod-visible"))},processLinkText=(e,t)=>{let A=null;if(e.search("#")>-1){const i=getLinkParts(e,t.file);A=`#${i.isBlockRef?"^":""}${i.ref}`,e=i.path}return e.match(REG_LINKINDEX_INVALIDCHARS)?{subpath:A,file:null}:{subpath:A,file:app.metadataCache.getFirstLinkpathDest(e,t.file.path)}},generateEmbeddableLink=(e,t)=>e;let versionUpdateChecked=!1;const checkExcalidrawVersion=async e=>{if(!versionUpdateChecked){versionUpdateChecked=!0;try{const e=async()=>JSON.parse(await obsidian_module.request({url:"https://api.github.com/repos/zsviczian/obsidian-excalidraw-plugin/releases?per_page=5&page=1"})),t=(await e()).map((e=>({version:e.tag_name,published:new Date(e.published_at)}))).filter((e=>e.version.match(/^\d+\.\d+\.\d+$/))).sort(((e,t)=>t.published-e.published))[0].version;isVersionNewerThanOther(t,PLUGIN_VERSION)&&new obsidian_module.Notice(`A newer version of Excalidraw is available in Community Plugins.\n\nYou are using ${PLUGIN_VERSION}.\nThe latest is ${t}`)}catch(e){errorlog({where:"Utils/checkExcalidrawVersion",error:e})}setTimeout((()=>versionUpdateChecked=!1),288e5)}};function wrapTextAtCharLength(e,t,A=!1,i=0){if(!t)return e;let n="";if(A){for(const A of e.split("\n")){const e=A.match(new RegExp(`(.){1,${t}}`,"g"));n+=e?`${e.join("\n")}\n`:"\n"}return n.replace(/\n$/,"")}const a=new RegExp(`(.{1,${t}})(\\s+|$\\n?)|([^\\s]{1,${t+i}})(\\s+|$\\n?)?`,"gm"),r=e.matchAll(a);let s;for(;!(s=r.next()).done;){n+=s.value[1]?s.value[1].trimEnd():s.value[3].trimEnd();const e=(s.value[2]?s.value[2].split("\n").length-1:0)+(s.value[4]?s.value[4].split("\n").length-1:0);n+="\n".repeat(e),0===e&&(n+="\n")}return n.replace(/\n$/,"")}new Random(Date.now());const rotate$1=(e,t,A,i,n)=>[(e-A)*Math.cos(n)-(t-i)*Math.sin(n)+A,(e-A)*Math.sin(n)+(t-i)*Math.cos(n)+i],rotatedDimensions=e=>{if(0===e.angle)return[e.x,e.y,e.width,e.height];const t=e.x+e.width/2,A=e.y+e.height/2,[i,n]=rotate$1(e.x,e.y,t,A,e.angle),[a,r]=rotate$1(e.x+e.width,e.y+e.height,t,A,e.angle);return[inew Promise(((A,i)=>{const n=new FileReader;n.onload=()=>{const e=n.result;A(e)},n.onerror=e=>i(e),n.readAsDataURL(new Blob([new Uint8Array(e)],{type:t}))})),getFontDataURL=async(e,t,A,i)=>{let n="",a="",r="";const s=e.metadataCache.getFirstLinkpathDest(t,A);if(s){const t=await e.vault.readBinary(s),A=s.extension.startsWith("woff")?"application/font-woff":"font/truetype";a=null!=i?i:s.basename,r=await getDataURL(t,A),n=` @font-face {font-family: "${a}";src: url("${r}") format("${"ttf"===s.extension?"truetype":s.extension}");}`;const o=n.split(";base64,",2);n=`${o[0]};charset=utf-8;base64,${o[1]}`}return{fontDef:n,fontName:a,dataURL:r}},svgToBase64=e=>`data:image/svg+xml;base64,${btoa(unescape(encodeURIComponent(e.replaceAll(" "," "))))}`,getBinaryFileFromDataURL=async e=>{if(!e)return null;if(e.match(/^(https?|ftp):\/\/[^\s/$.?#].[^\s]*$/i)){const t=e,A=getURLImageExtension(t),i=getMimeType(A);e=await getDataURLFromURL(t,i)}const t=e.matchAll(/base64,(.*)/g).next();if(!t.value)return null;const A=window.atob(t.value[1]),i=A.length,n=new Uint8Array(i);for(let e=0;e{var i;let n=e.elements;n.some((e=>"embeddable"===e.type))&&(n=JSON.parse(JSON.stringify(n)),n.filter((e=>"embeddable"===e.type)).forEach((t=>{var A,i;t.link=(i=t.link,null===(A=e.appState)||void 0===A||A.theme,i)})));try{return await exportToSvg({elements:n,appState:Object.assign({exportBackground:t.withBackground,exportWithDarkMode:!!t.withTheme&&"light"!=(null===(i=e.appState)||void 0===i?void 0:i.theme)},e.appState),files:e.files,exportPadding:A})}catch(e){return null}},getPNG=async(e,t,A,i=1)=>{var n;try{return await exportToBlob({elements:e.elements,appState:Object.assign({exportBackground:t.withBackground,exportWithDarkMode:!!t.withTheme&&"light"!=(null===(n=e.appState)||void 0===n?void 0:n.theme)},e.appState),files:e.files,exportPadding:A,mimeType:"image/png",getDimensions:(e,t)=>({width:e*i,height:t*i,scale:i})})}catch(e){return errorlog({where:"Utils.getPNG",error:e}),null}},getQuickImagePreview=async(e,t,A)=>{if(!e.settings.displayExportedImageIfAvailable)return null;const i=getIMGFilename(t,A),n=e.app.vault.getAbstractFileByPath(i);return n&&n instanceof obsidian_module.TFile?"png"===A?await e.app.vault.readBinary(n):await e.app.vault.read(n):null},embedFontsInSVG=(e,t)=>{const A=null!=e.querySelector("text[font-family^='Virgil']"),i=null!=e.querySelector("text[font-family^='Cascadia']"),n=null!=e.querySelector("text[font-family^='LocalFont']"),a=e.querySelector("defs");return a&&(i||A||n)&&(a.innerHTML=``),e},getImageSize=async e=>new Promise(((t,A)=>{const i=new Image;i.onload=()=>{t({height:i.naturalHeight,width:i.naturalWidth})},i.onerror=A,i.src=e})),scaleLoadedImage=(e,t)=>{let A=!1;if(!t||!e)return{dirty:A,scene:e};for(const i of t){const[t,n]=[i.size.width,i.size.height],a=i.size.width/i.size.height;e.elements.filter((e=>"image"===e.type&&e.fileId===i.id)).forEach((e=>{const[r,s]=[e.width,e.height];if(i.shouldScale){if(a!=r/s){A=!0;const i=Math.sqrt(r*s*n/t),a=Math.sqrt(r*s*t/n);e.height=i,e.width=a,e.y+=(s-i)/2,e.x+=(r-a)/2}}else r===t&&s===n||(A=!0,e.height=n,e.width=t,e.y+=(s-n)/2,e.x+=(r-t)/2)}))}return{dirty:A,scene:e}},setDocLeftHandedMode=(e,t)=>{const A=t.createElement("style");A.id="excalidraw-left-handed",A.textContent=".excalidraw .App-bottom-bar{justify-content:flex-end;}";const i=t.getElementById(A.id);i&&t.head.removeChild(i),e&&t.head.appendChild(A)},setLeftHandedMode=e=>{const t=new Set;app.workspace.iterateAllLeaves((A=>{const i=app.isMobile?document:A.view.containerEl.ownerDocument;i&&(t.has(i)||(t.add(i),setDocLeftHandedMode(e,i)))}))},getLinkParts=(e,t)=>{var A,i,n,a;const r=e.match(/(^[^#\|]*)#?(\^)?([^\|]*)?\|?(\d*)x?(\d*)/);return{original:e,path:t&&""===r[1]?t.path:r[1],isBlockRef:"^"===r[2],ref:(null===(A=r[3])||void 0===A?void 0:A.match(/^page=\d*$/i))?r[3]:null===(i=r[3])||void 0===i?void 0:i.replaceAll(REG_BLOCK_REF_CLEAN,""),width:r[4]?parseInt(r[4]):void 0,height:r[5]?parseInt(r[5]):void 0,page:parseInt(null===(a=null===(n=r[3])||void 0===n?void 0:n.match(/page=(\d*)/))||void 0===a?void 0:a[1])}},compress=e=>lzStringExports.compressToBase64(e).replace(/(.{64})/g,"$1\n\n"),decompress=e=>lzStringExports.decompressFromBase64(e.replaceAll("\n","").replaceAll("\r","")),hasExportTheme=(e,t)=>{if(t){const A=e.app.metadataCache.getFileCache(t);if((null==A?void 0:A.frontmatter)&&null!=A.frontmatter["excalidraw-export-dark"])return!0}return!1},getExportTheme=(e,t,A)=>{if(t){const A=e.app.metadataCache.getFileCache(t);if((null==A?void 0:A.frontmatter)&&null!=A.frontmatter["excalidraw-export-dark"])return A.frontmatter["excalidraw-export-dark"]?"dark":"light"}return e.settings.exportWithTheme?A:"light"},hasExportBackground=(e,t)=>{if(t){const A=e.app.metadataCache.getFileCache(t);if((null==A?void 0:A.frontmatter)&&null!=A.frontmatter["excalidraw-export-transparent"])return!0}return!1},getWithBackground=(e,t)=>{if(t){const A=e.app.metadataCache.getFileCache(t);if((null==A?void 0:A.frontmatter)&&null!=A.frontmatter["excalidraw-export-transparent"])return!A.frontmatter["excalidraw-export-transparent"]}return e.settings.exportWithBackground},getExportPadding=(e,t)=>{if(t){const A=e.app.metadataCache.getFileCache(t);if(!(null==A?void 0:A.frontmatter))return e.settings.exportPaddingSVG;if(null!=A.frontmatter["excalidraw-export-padding"]){const e=parseInt(A.frontmatter["excalidraw-export-padding"]);if(!isNaN(e))return e}if(null!=A.frontmatter["excalidraw-export-svgpadding"]){const e=parseInt(A.frontmatter["excalidraw-export-svgpadding"]);if(!isNaN(e))return e}}return e.settings.exportPaddingSVG},getPNGScale=(e,t)=>{if(t){const A=e.app.metadataCache.getFileCache(t);if((null==A?void 0:A.frontmatter)&&null!=A.frontmatter["excalidraw-export-pngscale"]){const e=parseFloat(A.frontmatter["excalidraw-export-pngscale"]);if(!isNaN(e)&&e>0)return e}}return e.settings.pngExportScale},isVersionNewerThanOther=(e,t)=>{const A=e.match(/(\d*)\.(\d*)\.(\d*)/),i=t.match(/(\d*)\.(\d*)\.(\d*)/);return Boolean(A&&4===A.length&&i&&4===i.length&&!(isNaN(parseInt(A[1]))||isNaN(parseInt(A[2]))||isNaN(parseInt(A[3])))&&!(isNaN(parseInt(i[1]))||isNaN(parseInt(i[2]))||isNaN(parseInt(i[3])))&&(parseInt(A[1])>parseInt(i[1])||parseInt(A[1])>=parseInt(i[1])&&parseInt(A[2])>parseInt(i[2])||parseInt(A[1])>=parseInt(i[1])&&parseInt(A[2])>=parseInt(i[2])&&parseInt(A[3])>parseInt(i[3])))},getEmbeddedFilenameParts=e=>{const t=null==e?void 0:e.match(/([^#\^]*)((#\^)(group=|area=|frame=|taskbone)?([^\|]*)|(#)(group=|area=|frame=|taskbone)?([^\^\|]*))(.*)/);return t?{filepath:t[1],hasBlockref:Boolean(t[3]),hasGroupref:"group="===t[4]||"group="===t[7],hasTaskbone:"taskbone"===t[4]||"taskbone"===t[7],hasArearef:"area="===t[4]||"area="===t[7],hasFrameref:"frame="===t[4]||"frame="===t[7],blockref:t[5],hasSectionref:Boolean(t[6]),sectionref:t[8],linkpartReference:t[2],linkpartAlias:t[9]}:{filepath:e,hasBlockref:!1,hasGroupref:!1,hasTaskbone:!1,hasArearef:!1,hasFrameref:!1,blockref:"",hasSectionref:!1,sectionref:"",linkpartReference:"",linkpartAlias:""}},fragWithHTML=e=>createFragment((t=>t.createDiv().innerHTML=e)),errorlog=e=>{console.error(Object.assign({plugin:"Excalidraw"},e))},sleep$1=async e=>new Promise((t=>setTimeout(t,e))),log=console.log.bind(window.console),debug=console.log.bind(window.console),getContainerElement=(e,t)=>{var A;return e&&e.containerId&&null!==(A=t.elements.filter((t=>t.id===e.containerId))[0])&&void 0!==A?A:null},updateFrontmatterInString=(e,t)=>{if(!e)return e;for(const A of t){const t=new RegExp(`${A[0]}:\\s.*\\n`,"g");e=e.match(t)?e.replaceAll(t,`${A[0]}: ${A[1]}\n`):e.replace(/^---\n/,`---\n${A[0]}: ${A[1]}\n`)}return e},isHyperlink=e=>e&&!e.includes("\n")&&!e.includes("\r")&&e.match(/^https?:(\d*)?\/\/[^\s]*$/),isContainer=e=>{var t;return"arrow"!==e.type&&(null===(t=e.boundElements)||void 0===t?void 0:t.map((e=>e.type)).includes("text"))},hyperlinkIsImage=e=>{isHyperlink(e);const t=e.split("?")[0];return IMAGE_TYPES.contains(t.substring(t.lastIndexOf(".")+1))},hyperlinkIsYouTubeLink=e=>isHyperlink(e)&&(e.startsWith("https://youtu.be")||e.startsWith("https://www.youtube.com")||e.startsWith("https://youtube.com")||e.startsWith("https//www.youtu.be"))&&null!==e.match(/(youtu.be\/|v=)([^?\/\&]*)/),getYouTubeThumbnailLink=async e=>{const t=e.match(/(youtu.be\/|v=)([^?\/\&]*)/);if(!t||!t[2])return null;const A=t[2];let i=`https://i.ytimg.com/vi/${A}/maxresdefault.jpg`,n=await obsidian_module.requestUrl({url:i,method:"get",contentType:"image/jpeg",throw:!1});return n&&200===n.status?i:(i=`https://i.ytimg.com/vi/${A}/hq720.jpg`,n=await obsidian_module.requestUrl({url:i,method:"get",contentType:"image/jpeg",throw:!1}),n&&200===n.status?i:(i=`https://i.ytimg.com/vi/${A}/mqdefault.jpg`,n=await obsidian_module.requestUrl({url:i,method:"get",contentType:"image/jpeg",throw:!1}),n&&200===n.status?i:`https://i.ytimg.com/vi/${A}/default.jpg`))};var ar={},cz={},da={},de={},en={INSTALL_SCRIPT:"Install the script",UPDATE_SCRIPT:"Update available - Click to install",CHECKING_SCRIPT:"Checking for newer version - Click to reinstall",UNABLETOCHECK_SCRIPT:"Update check failed - Click to reinstall",UPTODATE_SCRIPT:"Script is up to date - Click to reinstall",OPEN_AS_EXCALIDRAW:"Open as Excalidraw Drawing",TOGGLE_MODE:"Toggle between Excalidraw and Markdown mode",CONVERT_NOTE_TO_EXCALIDRAW:"Convert empty note to Excalidraw Drawing",CONVERT_EXCALIDRAW:"Convert *.excalidraw to *.md files",CREATE_NEW:"Create new drawing",CONVERT_FILE_KEEP_EXT:"*.excalidraw => *.excalidraw.md",CONVERT_FILE_REPLACE_EXT:"*.excalidraw => *.md (Logseq compatibility)",DOWNLOAD_LIBRARY:"Export stencil library as an *.excalidrawlib file",OPEN_EXISTING_NEW_PANE:"Open existing drawing - IN A NEW PANE",OPEN_EXISTING_ACTIVE_PANE:"Open existing drawing - IN THE CURRENT ACTIVE PANE",TRANSCLUDE:"Embed a drawing",TRANSCLUDE_MOST_RECENT:"Embed the most recently edited drawing",TOGGLE_LEFTHANDED_MODE:"Toggle left-handed mode",NEW_IN_NEW_PANE:"Create new drawing - IN AN ADJACENT WINDOW",NEW_IN_NEW_TAB:"Create new drawing - IN A NEW TAB",NEW_IN_ACTIVE_PANE:"Create new drawing - IN THE CURRENT ACTIVE WINDOW",NEW_IN_POPOUT_WINDOW:"Create new drawing - IN A POPOUT WINDOW",NEW_IN_NEW_PANE_EMBED:"Create new drawing - IN AN ADJACENT WINDOW - and embed into active document",NEW_IN_NEW_TAB_EMBED:"Create new drawing - IN A NEW TAB - and embed into active document",NEW_IN_ACTIVE_PANE_EMBED:"Create new drawing - IN THE CURRENT ACTIVE WINDOW - and embed into active document",NEW_IN_POPOUT_WINDOW_EMBED:"Create new drawing - IN A POPOUT WINDOW - and embed into active document",TOGGLE_LOCK:"Toggle Text Element between edit RAW and PREVIEW",DELETE_FILE:"Delete selected image or Markdown file from Obsidian Vault",INSERT_LINK_TO_ELEMENT:`Copy markdown link for selected element to clipboard. ${labelCTRL()}+CLICK to copy 'group=' link. SHIFT+CLICK to copy an 'area=' link. ${labelALT()}+CLICK to watch a help video.`,INSERT_LINK_TO_ELEMENT_GROUP:"Copy 'group=' markdown link for selected element to clipboard.",INSERT_LINK_TO_ELEMENT_AREA:"Copy 'area=' markdown link for selected element to clipboard.",INSERT_LINK_TO_ELEMENT_FRAME:"Copy 'frame=' markdown link for selected element to clipboard.",INSERT_LINK_TO_ELEMENT_NORMAL:"Copy markdown link for selected element to clipboard.",INSERT_LINK_TO_ELEMENT_ERROR:"Select a single element in the scene",INSERT_LINK_TO_ELEMENT_READY:"Link is READY and available on the clipboard",INSERT_LINK:"Insert link to file",INSERT_IMAGE:"Insert image or Excalidraw drawing from your vault",IMPORT_SVG:"Import an SVG file as Excalidraw strokes (limited SVG support, TEXT currently not supported)",INSERT_MD:"Insert markdown file from vault",INSERT_PDF:"Insert PDF file from vault",UNIVERSAL_ADD_FILE:"Insert ANY file from your Vault to the active drawing",INSERT_LATEX:`Insert LaTeX formula (e.g. \\binom{n}{k} = \\frac{n!}{k!(n-k)!}). ${labelALT()}+CLICK to watch a help video.`,ENTER_LATEX:"Enter a valid LaTeX expression",READ_RELEASE_NOTES:"Read latest release notes",RUN_OCR:"OCR: Grab text from freedraw scribble and pictures to clipboard",TRAY_MODE:"Toggle property-panel tray-mode",SEARCH:"Search for text in drawing",RESET_IMG_TO_100:"Set selected image element size to 100% of original",TEMPORARY_DISABLE_AUTOSAVE:"Disable autosave until next time Obsidian starts (only set this if you know what you are doing)",TEMPORARY_ENABLE_AUTOSAVE:"Enable autosave",INSTALL_SCRIPT_BUTTON:"Install or update Excalidraw Scripts",OPEN_AS_MD:"Open as Markdown",EXPORT_IMAGE:"Export Image",OPEN_LINK:"Open selected text as link\n(SHIFT+CLICK to open in a new pane)",EXPORT_EXCALIDRAW:"Export to an .Excalidraw file",LINK_BUTTON_CLICK_NO_TEXT:"Select a ImageElement, or select a TextElement that contains an internal or external link.\n",FILENAME_INVALID_CHARS:'File name cannot contain any of the following characters: * " \\ < > : | ? #',FORCE_SAVE:"Save (will also update transclusions)",RAW:"Change to PREVIEW mode (only affects text-elements with links or transclusions)",PARSED:"Change to RAW mode (only affects text-elements with links or transclusions)",NOFILE:"Excalidraw (no file)",COMPATIBILITY_MODE:"*.excalidraw file opened in compatibility mode. Convert to new format for full plugin functionality.",CONVERT_FILE:"Convert to new format",BACKUP_AVAILABLE:"We encountered an error while loading your drawing. This might have occurred if Obsidian unexpectedly closed during a save operation. For example, if you accidentally closed Obsidian on your mobile device while saving.

GOOD NEWS: Fortunately, a local backup is available. However, please note that if you last modified this drawing on a different device (e.g., tablet) and you are now on your desktop, that other device likely has a more recent backup.

I recommend trying to open the drawing on your other device first and restore the backup from its local storage.

Would you like to load the backup?",BACKUP_RESTORED:"Backup restored",CACHE_NOT_READY:"I apologize for the inconvenience, but an error occurred while loading your file.

Having a little patience can save you a lot of time...

The plugin has a backup cache, but it appears that you have just started Obsidian. Initializing the Backup Cache may take some time, usually up to a minute or more depending on your device's performance. You will receive a notification in the top right corner when the cache initialization is complete.

Please press OK to attempt loading the file again and check if the cache has finished initializing. If you see a completely empty file behind this message, I recommend waiting until the backup cache is ready before proceeding. Alternatively, you can choose Cancel to manually correct your file.
",OBSIDIAN_TOOLS_PANEL:"Obsidian Tools Panel",ERROR_SAVING_IMAGE:"Unknown error occured while fetching the image. It could be that for some reason the image is not available or rejected the fetch request from Obsidian",RELEASE_NOTES_NAME:"Display Release Notes after update",RELEASE_NOTES_DESC:"Toggle ON: Display release notes each time you update Excalidraw to a newer version.
Toggle OFF: Silent mode. You can still read release notes on GitHub.",NEWVERSION_NOTIFICATION_NAME:"Plugin update notification",NEWVERSION_NOTIFICATION_DESC:"Toggle ON: Show a notification when a new version of the plugin is available.
Toggle OFF: Silent mode. You need to check for plugin updates in Community Plugins.",FOLDER_NAME:"Excalidraw folder",FOLDER_DESC:"Default location for new drawings. If empty, drawings will be created in the Vault root.",FOLDER_EMBED_NAME:"Use Excalidraw folder when embedding a drawing into the active document",FOLDER_EMBED_DESC:"Define which folder to place the newly inserted drawing into when using the command palette action: 'Create a new drawing and embed into active document'.
Toggle ON: Use Excalidraw folder
Toggle OFF: Use the attachments folder defined in Obsidian settings.",TEMPLATE_NAME:"Excalidraw template file",TEMPLATE_DESC:"Full filepath to the Excalidraw template. E.g.: If your template is in the default Excalidraw folder and its name is Template.md, the setting would be: Excalidraw/Template.md (or just Excalidraw/Template - you may omit the .md file extension). If you are using Excalidraw in compatibility mode, then your template must be a legacy Excalidraw file as well such as Excalidraw/Template.excalidraw.",SCRIPT_FOLDER_NAME:"Excalidraw Automate script folder (CASE SeNSitiVE!)",SCRIPT_FOLDER_DESC:"The files you place in this folder will be treated as Excalidraw Automate scripts. You can access your scripts from Excalidraw via the Obsidian Command Palette. Assign hotkeys to your favorite scripts just like to any other Obsidian command. The folder may not be the root folder of your Vault. ",SAVING_HEAD:"Saving",COMPRESS_NAME:"Compress Excalidraw JSON in Markdown",COMPRESS_DESC:"By enabling this feature Excalidraw will store the drawing JSON in a Base64 compressed format using the LZ-String algorithm. This will reduce the chance of Excalidraw JSON cluttering your search results in Obsidian. As a side effect, this will also reduce the filesize of Excalidraw drawings. When you switch an Excalidraw drawing to Markdown view, using the options menu in Excalidraw, the file will be saved without compression, so that you can read and edit the JSON string. The drawing will be compressed again once you switch back to Excalidraw view. The setting only has effect 'point forward', meaning, existing drawings will not be affected by the setting until you open them and save them.
Toggle ON: Compress drawing JSON
Toggle OFF: Leave drawing JSON uncompressed",AUTOSAVE_INTERVAL_DESKTOP_NAME:"Interval for autosave on Desktop",AUTOSAVE_INTERVAL_DESKTOP_DESC:"The time interval between saves. Autosave will skip if there are no changes in the drawing. Excalidraw will also save the file when closing a workspace tab or navigating within Obsidian, but away from the active Excalidraw tab (i.e. clicking on the Obsidian ribbon or checking backlinks, etc.). Excalidraw will not be able to save your work when terminating Obsidian directly either by killing the Obsidian process, or clicking to close Obsidian altogether.",AUTOSAVE_INTERVAL_MOBILE_NAME:"Interval for autosave on Mobile",AUTOSAVE_INTERVAL_MOBILE_DESC:"I recommend a more frequent interval for Mobiles. Excalidraw will also save the file when closing a workspace tab or navigating within Obsidian, but away from the active Excalidraw tab (i.e. tapping on the Obsidian ribbon or checking backlinks, etc.). Excalidraw will not be able to save your work when terminating Obsidian directly (i.e. swiping it away). Also note, that when you switch apps on a Mobile device, sometimes Android and iOS closes Obsidian in the background to save system resources. In such a case Excalidraw will not be able to save the latest changes.",FILENAME_HEAD:"Filename",FILENAME_DESC:"

Click this link for the date and time format reference.

",FILENAME_SAMPLE:"Filename for a new drawing is: ",FILENAME_EMBED_SAMPLE:"Filename for a new embedded drawing is: ",FILENAME_PREFIX_NAME:"Filename prefix",FILENAME_PREFIX_DESC:"The first part of the filename",FILENAME_PREFIX_EMBED_NAME:"Filename prefix when embedding a new drawing into a markdown note",FILENAME_PREFIX_EMBED_DESC:"Should the filename of the newly inserted drawing start with the name of the active markdown note when using the command palette action: Create a new drawing and embed into active document?
Toggle ON: Yes, the filename of a new drawing should start with filename of the active document
Toggle OFF: No, filename of a new drawing should not include the filename of the active document",FILENAME_POSTFIX_NAME:"Custom text after markdown Note's name when embedding",FILENAME_POSTFIX_DESC:"Affects filename only when embedding into a markdown document. This text will be inserted after the note's name, but before the date.",FILENAME_DATE_NAME:"Filename Date",FILENAME_DATE_DESC:"The last part of the filename. Leave empty if you do not want a date.",FILENAME_EXCALIDRAW_EXTENSION_NAME:".excalidraw.md or .md",FILENAME_EXCALIDRAW_EXTENSION_DESC:"This setting does not apply if you use Excalidraw in compatibility mode, i.e. you are not using Excalidraw markdown files.
Toggle ON: filename ends with .excalidraw.md
Toggle OFF: filename ends with .md",DISPLAY_HEAD:"Display",DYNAMICSTYLE_NAME:"Dynamic styling",DYNAMICSTYLE_DESC:"Change Excalidraw UI colors to match the canvas color",LEFTHANDED_MODE_NAME:"Left-handed mode",LEFTHANDED_MODE_DESC:"Currently only has effect in tray-mode. If turned on, the tray will be on the right side.
Toggle ON: Left-handed mode.
Toggle OFF: Right-handed moded",IFRAME_MATCH_THEME_NAME:"IFrames (markdown embeds) to match Excalidraw theme",IFRAME_MATCH_THEME_DESC:"Set this to true if you are for example using Obsidian in dark mode but use excalidraw with a light background. With this setting the embedded Obsidian markdown document will match the Excalidraw theme (i.e. light colors if Excalidraw is in light mode). ",MATCH_THEME_NAME:"New drawing to match Obsidian theme",MATCH_THEME_DESC:"If theme is dark, new drawing will be created in dark mode. This does not apply when you use a template for new drawings. Also this will not affect when you open an existing drawing. Those will follow the theme of the template/drawing respectively.
Toggle ON: Follow Obsidian Theme
Toggle OFF: Follow theme defined in your template",MATCH_THEME_ALWAYS_NAME:"Existing drawings to match Obsidian theme",MATCH_THEME_ALWAYS_DESC:"If theme is dark, drawings will be opened in dark mode. If your theme is light, they will be opened in light mode.
Toggle ON: Match Obsidian theme
Toggle OFF: Open with the same theme as last saved",MATCH_THEME_TRIGGER_NAME:"Excalidraw to follow when Obsidian Theme changes",MATCH_THEME_TRIGGER_DESC:"If this option is enabled open Excalidraw pane will switch to light/dark mode when Obsidian theme changes.
Toggle ON: Follow theme changes
Toggle OFF: Drawings are not affected by Obsidian theme changes",DEFAULT_OPEN_MODE_NAME:"Default mode when opening Excalidraw",DEFAULT_OPEN_MODE_DESC:"Specifies the mode how Excalidraw opens: Normal, Zen, or View mode. You may also set this behavior on a file level by adding the excalidraw-default-mode frontmatter key with a value of: normal, view, or zen to your document.",DEFAULT_PEN_MODE_NAME:"Pen mode",DEFAULT_PEN_MODE_DESC:"Should pen mode be automatically enabled when opening Excalidraw?",DEFAULT_PINCHZOOM_NAME:"Allow pinch zoom in pen mode",DEFAULT_PINCHZOOM_DESC:"Pinch zoom in pen mode when using the freedraw tool is disabled by default to prevent unwanted accidental zooming with your palm.
Toggle on: Enable pinch zoom in pen mode
Toggle off: Disable pinch zoom in pen mode",DEFAULT_WHEELZOOM_NAME:"Mouse wheel to zoom by default",DEFAULT_WHEELZOOM_DESC:`Toggle on: Mouse wheel to zoom; ${labelCTRL()} + mouse wheel to scroll
Toggle off: ${labelCTRL()} + mouse wheel to zoom; Mouse wheel to scroll`,ZOOM_TO_FIT_NAME:"Zoom to fit on view resize",ZOOM_TO_FIT_DESC:"Zoom to fit drawing when the pane is resized
Toggle ON: Zoom to fit
Toggle OFF: Auto zoom disabled",ZOOM_TO_FIT_ONOPEN_NAME:"Zoom to fit on file open",ZOOM_TO_FIT_ONOPEN_DESC:"Zoom to fit drawing when the drawing is first opened
Toggle ON: Zoom to fit
Toggle OFF: Auto zoom disabled",ZOOM_TO_FIT_MAX_LEVEL_NAME:"Zoom to fit max ZOOM level",ZOOM_TO_FIT_MAX_LEVEL_DESC:"Set the maximum level to which zoom to fit will enlarge the drawing. Minimum is 0.5 (50%) and maximum is 10 (1000%).",LINKS_HEAD:"Links and transclusion",LINKS_DESC:`${labelCTRL()}+CLICK on [[Text Elements]] to open them as links. If the selected text has more than one [[valid Obsidian links]], only the first will be opened. If the text starts as a valid web link (i.e. https:// or http://), then the plugin will open it in a browser. When Obsidian files change, the matching [[link]] in your drawings will also change. If you don't want text accidentally changing in your drawings use [[links|with aliases]].`,ADJACENT_PANE_NAME:"Reuse adjacent pane",ADJACENT_PANE_DESC:`When ${labelCTRL()}+SHIFT clicking a link in Excalidraw, by default the plugin will open the link in a new pane. Turning this setting on, Excalidraw will first look for an existing pane, and try to open the link there. Excalidraw will look for the other workspace pane based on your focus/navigation history, i.e. the workpane that was active before you activated Excalidraw.`,MAINWORKSPACE_PANE_NAME:"Open in main workspace",MAINWORKSPACE_PANE_DESC:`When ${labelCTRL()}+SHIFT clicking a link in Excalidraw, by default the plugin will open the link in a new pane in the current active window. Turning this setting on, Excalidraw will open the link in an existing or new pane in the main workspace. `,LINK_BRACKETS_NAME:"Show [[brackets]] around links",LINK_BRACKETS_DESC:"In PREVIEW mode, when parsing Text Elements, place brackets around links. You can override this setting for a specific drawing by adding excalidraw-link-brackets: true/false to the file's frontmatter.",LINK_PREFIX_NAME:"Link prefix",LINK_PREFIX_DESC:'In PREVIEW mode, if the Text Element contains a link, precede the text with these characters. You can override this setting for a specific drawing by adding excalidraw-link-prefix: "📍 " to the file\'s frontmatter.',URL_PREFIX_NAME:"URL prefix",URL_PREFIX_DESC:'In PREVIEW mode, if the Text Element contains a URL link, precede the text with these characters. You can override this setting for a specific drawing by adding excalidraw-url-prefix: "🌐 " to the file\'s frontmatter.',PARSE_TODO_NAME:"Parse todo",PARSE_TODO_DESC:"Convert '- [ ] ' and '- [x] ' to checkpox and tick in the box.",TODO_NAME:"Open TODO icon",TODO_DESC:"Icon to use for open TODO items",DONE_NAME:"Completed TODO icon",DONE_DESC:"Icon to use for completed TODO items",HOVERPREVIEW_NAME:`Hover preview without pressing the ${labelCTRL()} key`,HOVERPREVIEW_DESC:`Toggle On: In Exalidraw view mode the hover preview for [[wiki links]] will be shown immediately, without the need to hold the ${labelCTRL()} key. In Excalidraw normal mode, the preview will be shown immediately only when hovering the blue link icon in the top right of the element.
Toggle Off: Hover preview is shown only when you hold the ${labelCTRL()} key while hovering the link.`,LINKOPACITY_NAME:"Opacity of link icon",LINKOPACITY_DESC:"Opacity of the link indicator icon in the top right corner of an element. 1 is opaque, 0 is transparent.",LINK_CTRL_CLICK_NAME:`${labelCTRL()}+CLICK on text with [[links]] or [](links) to open them`,LINK_CTRL_CLICK_DESC:"You can turn this feature off if it interferes with default Excalidraw features you want to use. If this is turned off, only the link button in the title bar of the drawing pane will open links.",TRANSCLUSION_WRAP_NAME:"Overflow wrap behavior of transcluded text",TRANSCLUSION_WRAP_DESC:"Number specifies the character count where the text should be wrapped. Set the text wrapping behavior of transcluded text. Turn this ON to force-wrap text (i.e. no overflow), or OFF to soft-wrap text (at the nearest whitespace).",TRANSCLUSION_DEFAULT_WRAP_NAME:"Transclusion word wrap default",TRANSCLUSION_DEFAULT_WRAP_DESC:"You can manually set/override word wrapping length using the `![[page#^block]]{NUMBER}` format. Normally you will not want to set a default, because if you transclude text inside a sticky note, then Excalidraw will automatically take care of word wrapping. Set this value to `0` if you do not want to set a default. ",PAGE_TRANSCLUSION_CHARCOUNT_NAME:"Page transclusion max char count",PAGE_TRANSCLUSION_CHARCOUNT_DESC:"The maximum number of characters to display from the page when transcluding an entire page with the ![[markdown page]] format.",QUOTE_TRANSCLUSION_REMOVE_NAME:"Quote translusion: remove leading '> ' from each line",QUOTE_TRANSCLUSION_REMOVE_DESC:"Remove the leading '> ' from each line of the transclusion. This will improve readability of quotes in text only transclusions
Toggle ON: Remove leading '> '
Toggle OFF: Do not remove leading '> ' (note it will still be removed from the first row due to Obsidian API functionality)",GET_URL_TITLE_NAME:"Use iframely to resolve page title",GET_URL_TITLE_DESC:"Use the http://iframely.server.crestify.com/iframely?url= to get title of page when dropping a link into Excalidraw",MD_HEAD:"Markdown-embed settings",MD_HEAD_DESC:"You can transclude formatted markdown documents into drawings as images SHIFT drop from the file explorer or using the command palette action.",MD_TRANSCLUDE_WIDTH_NAME:"Default width of a transcluded markdown document",MD_TRANSCLUDE_WIDTH_DESC:"The width of the markdown page. This affects the word wrapping when transcluding longer paragraphs, and the width of the image element. You can override the default width of an embedded file using the [[filename#heading|WIDTHxMAXHEIGHT]] syntax in markdown view mode under embedded files.",MD_TRANSCLUDE_HEIGHT_NAME:"Default maximum height of a transcluded markdown document",MD_TRANSCLUDE_HEIGHT_DESC:"The embedded image will be as high as the markdown text requires, but not higher than this value. You can override this value by editing the embedded image link in markdown view mode with the following syntax [[filename#^blockref|WIDTHxMAXHEIGHT]].",MD_DEFAULT_FONT_NAME:"The default font typeface to use for embedded markdown files.",MD_DEFAULT_FONT_DESC:'Set this value to "Virgil" or "Cascadia" or the filename of a valid .ttf, .woff, or .woff2 font e.g. MyFont.woff2 You can override this setting by adding the following frontmatter-key to the embedded markdown file: excalidraw-font: font_or_filename',MD_DEFAULT_COLOR_NAME:"The default font color to use for embedded markdown files.",MD_DEFAULT_COLOR_DESC:'Set this to any valid css color name e.g. "steelblue" (color names), or a valid hexadecimal color e.g. "#e67700", or any other valid css color string. You can override this setting by adding the following frontmatter-key to the embedded markdown file: excalidraw-font-color: steelblue',MD_DEFAULT_BORDER_COLOR_NAME:"The default border color to use for embedded markdown files.",MD_DEFAULT_BORDER_COLOR_DESC:'Set this to any valid css color name e.g. "steelblue" (color names), or a valid hexadecimal color e.g. "#e67700", or any other valid css color string. You can override this setting by adding the following frontmatter-key to the embedded markdown file: excalidraw-border-color: gray. Leave empty if you don\'t want a border. ',MD_CSS_NAME:"CSS file",MD_CSS_DESC:`The filename of the CSS to apply to markdown embeds. Provide the filename with extension (e.g. 'md-embed.css'). The css file may also be a plain markdown file (e.g. 'md-embed-css.md'), just make sure the content is written using valid css syntax. If you need to look at the HTML code you are applying the CSS to, then open Obsidian Developer Console (${DEVICE.isIOS||DEVICE.isMacOS?"CMD+OPT+i":"CTRL+SHIFT+i"}) and type in the following command: "ExcalidrawAutomate.mostRecentMarkdownSVG". This will display the most recent SVG generated by Excalidraw. Setting the font-family in the css is has limitations. By default only your operating system's standard fonts are available (see README for details). You can add one custom font beyond that using the setting above. You can override this css setting by adding the following frontmatter-key to the embedded markdown file: "excalidraw-css: css_file_in_vault|css-snippet".`,EMBED_HEAD:"Embed & Export",EMBED_IMAGE_CACHE_NAME:"Cache images for embedding in markdown",EMBED_IMAGE_CACHE_DESC:"Cache images for embedding in markdown. This will speed up the embedding process, but in case you compose images of several sub-component drawings, the embedded image in Markdown won't update until you open the drawing and save it to trigger an update of the cache.",EMBED_IMAGE_CACHE_CLEAR:"Purge Cache",BACKUP_CACHE_CLEAR:"Purge Backups",BACKUP_CACHE_CLEAR_CONFIRMATION:"This action will delete all Excalidraw drawing backups. Backups are used as a safety measure in case your drawing file gets damaged. Each time you open Obsidian the plugin automatically deletes backups for files that no longer exist in your Vault. Are you sure you want to clear all backups?",EMBED_REUSE_EXPORTED_IMAGE_NAME:"If found, use the already exported image for preview",EMBED_REUSE_EXPORTED_IMAGE_DESC:"This setting works in conjunction with the Auto-export SVG/PNG setting. If an exported image that matches the file name of the drawing is available, use that image instead of generating a preview image on the fly. This will result in faster previews especially when you have many embedded objects in the drawing, however, it may happen that your latest changes are not displayed and that the image will not automatically match your Obsidian theme in case you have changed the Obsidian theme since the export was created. This setting only applies to embedding images into markdown documents. For a number of reasons, the same approach cannot be used to expedite the loading of drawings with many embedded objects. See demonstration here.",EMBED_PREVIEW_SVG_NAME:"Display SVG in markdown preview",EMBED_PREVIEW_SVG_DESC:"Toggle ON: Embed drawing as an SVG image into the markdown preview.
Toggle OFF: Embed drawing as a PNG image. Note, that some of the image block referencing features do not work with PNG embeds.",PREVIEW_MATCH_OBSIDIAN_NAME:"Excalidraw preview to match Obsidian theme",PREVIEW_MATCH_OBSIDIAN_DESC:"Image preview in documents should match the Obsidian theme. If enabled, when Obsidian is in dark mode, Excalidraw images will render in dark mode. When Obsidian is in light mode, Excalidraw will render light mode as well. You may want to switch 'Export image with background' off for a more Obsidian-integrated look and feel.",EMBED_WIDTH_NAME:"Default width of embedded (transcluded) image",EMBED_WIDTH_DESC:"The default width of an embedded drawing. This applies to live preview edit and reading mode, as well as to hover previews. You can specify a custom width when embedding an image using the ![[drawing.excalidraw|100]] or [[drawing.excalidraw|100x100]] format.",EMBED_TYPE_NAME:"Type of file to insert into the document",EMBED_TYPE_DESC:"When you embed an image into a document using the command palette this setting will specify if Excalidraw should embed the original Excalidraw file or a PNG or an SVG copy. You need to enable auto-export PNG / SVG (see below under Export Settings) for those image types to be available in the dropdown. For drawings that do not have a a corresponding PNG or SVG readily available the command palette action will insert a broken link. You need to open the original drawing and initiate export manually. This option will not autogenerate PNG/SVG files, but will simply reference the already existing files.",EMBED_WIKILINK_NAME:"Embed Drawing using Wiki link",EMBED_WIKILINK_DESC:"Toggle ON: Excalidraw will embed a [[wiki link]]. Toggle OFF: Excalidraw will embed a [markdown](link).",EXPORT_PNG_SCALE_NAME:"PNG export image scale",EXPORT_PNG_SCALE_DESC:"The size-scale of the exported PNG image",EXPORT_BACKGROUND_NAME:"Export image with background",EXPORT_BACKGROUND_DESC:"If turned off, the exported image will be transparent.",EXPORT_PADDING_NAME:"Image Padding",EXPORT_PADDING_DESC:"The padding (in pixels) around the exported SVG or PNG image. If you have curved lines close to the edge of the image they might get cropped during image export. You can increase this value to avoid cropping. You can also override this setting at a file level by adding the excalidraw-export-padding: 5 frontmatter key.",EXPORT_THEME_NAME:"Export image with theme",EXPORT_THEME_DESC:"Export the image matching the dark/light theme of your drawing. If turned off, drawings created in dark mode will appear as they would in light mode.",EXPORT_HEAD:"Auto-export Settings",EXPORT_SYNC_NAME:"Keep the .SVG and/or .PNG filenames in sync with the drawing file",EXPORT_SYNC_DESC:"When turned on, the plugin will automatically update the filename of the .SVG and/or .PNG files when the drawing in the same folder (and same name) is renamed. The plugin will also automatically delete the .SVG and/or .PNG files when the drawing in the same folder (and same name) is deleted. ",EXPORT_SVG_NAME:"Auto-export SVG",EXPORT_SVG_DESC:"Automatically create an SVG export of your drawing matching the title of your file. The plugin will save the *.SVG file in the same folder as the drawing. Embed the .svg file into your documents instead of Excalidraw making you embeds platform independent. While the auto-export switch is on, this file will get updated every time you edit the Excalidraw drawing with the matching name. You can override this setting on a file level by adding the excalidraw-autoexport frontmatter key. Valid values for this key are none,both,svg, and png",EXPORT_PNG_NAME:"Auto-export PNG",EXPORT_PNG_DESC:"Same as the auto-export SVG, but for *.PNG",EXPORT_BOTH_DARK_AND_LIGHT_NAME:"Export both dark- and light-themed image",EXPORT_BOTH_DARK_AND_LIGHT_DESC:"When enabled, Excalidraw will export two files instead of one: filename.dark.png, filename.light.png and/or filename.dark.svg and filename.light.svg
Double files will be exported both if auto-export SVG or PNG (or both) are enabled, as well as when clicking export on a single image.",COMPATIBILITY_HEAD:"Compatibility features",EXPORT_EXCALIDRAW_NAME:"Auto-export Excalidraw",EXPORT_EXCALIDRAW_DESC:"Same as the auto-export SVG, but for *.Excalidraw",SYNC_EXCALIDRAW_NAME:"Sync *.excalidraw with *.md version of the same drawing",SYNC_EXCALIDRAW_DESC:"If the modified date of the *.excalidraw file is more recent than the modified date of the *.md file then update the drawing in the .md file based on the .excalidraw file",COMPATIBILITY_MODE_NAME:"New drawings as legacy files",COMPATIBILITY_MODE_DESC:"By enabling this feature drawings you create with the ribbon icon, the command palette actions, and the file explorer are going to be all legacy *.excalidraw files. This setting will also turn off the reminder message when you open a legacy file for editing.",MATHJAX_NAME:"MathJax (LaTeX) javascript library host",MATHJAX_DESC:"If you are using LaTeX equiations in Excalidraw then the plugin needs to load a javascript library for that. Some users are unable to access certain host servers. If you are experiencing issues try changing the host here. You may need to restart Obsidian after closing settings, for this change to take effect.",LATEX_DEFAULT_NAME:"Default LaTeX formual for new equations",LATEX_DEFAULT_DESC:"Leave empty if you don't want a default formula. You can add default formatting here such as \\color{white}.",NONSTANDARD_HEAD:"Non-Excalidraw.com supported features",NONSTANDARD_DESC:"These features are not available on excalidraw.com. When exporting the drawing to Excalidraw.com these features will appear different.",CUSTOM_PEN_NAME:"Number of custom pens",CUSTOM_PEN_DESC:"You will see these pens next to the Obsidian Menu on the canvas. You can customize the pens on the canvas by long-pressing the pen button.",EXPERIMENTAL_HEAD:"Experimental features",EXPERIMENTAL_DESC:"Some of these setting will not take effect immediately, only when the File Explorer is refreshed, or Obsidian restarted.",FIELD_SUGGESTER_NAME:"Enable Field Suggester",FIELD_SUGGESTER_DESC:"Field Suggester borrowed from Breadcrumbs and Templater plugins. The Field Suggester will show an autocomplete menu when you type excalidraw- or ea. with function description as hints on the individual items in the list.",FILETYPE_NAME:"Display type (✏️) for excalidraw.md files in File Explorer",FILETYPE_DESC:"Excalidraw files will receive an indicator using the emoji or text defined in the next setting.",FILETAG_NAME:"Set the type indicator for excalidraw.md files",FILETAG_DESC:"The text or emoji to display as type indicator.",INSERT_EMOJI:"Insert an emoji",LIVEPREVIEW_NAME:"Immersive image embedding in live preview editing mode",LIVEPREVIEW_DESC:"Turn this on to support image embedding styles such as ![[drawing|width|style]] in live preview editing mode. The setting will not affect the currently open documents. You need close the open documents and re-open them for the change to take effect.",ENABLE_FOURTH_FONT_NAME:"Enable fourth font option",ENABLE_FOURTH_FONT_DESC:"By turning this on, you will see a fourth font button on the properties panel for text elements. Files that use this fourth font will (partly) lose their platform independence. Depending on the custom font set in settings, they will look differently when loaded in another vault, or at a later time. Also the 4th font will display as system default font on excalidraw.com, or other Excalidraw versions.",FOURTH_FONT_NAME:"Fourth font file",FOURTH_FONT_DESC:"Select a .ttf, .woff or .woff2 font file from your vault to use as the fourth font. If no file is selected, Excalidraw will use the Virgil font by default.",SCRIPT_SETTINGS_HEAD:"Settings for installed Scripts",TASKBONE_HEAD:"Taskbone Optical Character Recogntion",TASKBONE_DESC:"This is an experimental integration of optical character recognition into Excalidraw. Please note, that taskbone is an independent external service not provided by Excalidraw, nor the Excalidraw-Obsidian plugin project. The OCR service will grab legible text from freedraw lines and embedded pictures on your canvas and place the recognized text in the frontmatter of your drawing as well as onto clipboard. Having the text in the frontmatter will enable you to search in Obsidian for the text contents of these. Note, that the process of extracting the text from the image is not done locally, but via an online API. The taskbone service stores the image on its servers only as long as necessary for the text extraction. However, if this is a dealbreaker, then please don't use this feature.",TASKBONE_ENABLE_NAME:"Enable Taskbone",TASKBONE_ENABLE_DESC:"By enabling this service your agree to the Taskbone Terms and Conditions and the Privacy Policy.",TASKBONE_APIKEY_NAME:"Taskbone API Key",TASKBONE_APIKEY_DESC:"Taskbone offers a free service with a reasonable number of scans per month. If you want to use this feature more frequently, or you want to supoprt the developer of Taskbone (as you can imagine, there is no such thing as 'free', providing this awesome OCR service costs some money to the developer of Taskbone), you can purchase a paid API key from taskbone.com. In case you have purchased a key, simply overwrite this auto generated free-tier API-key with your paid key.",SELECT_FILE:"Select a file then press enter.",SELECT_FILE_WITH_OPTION_TO_SCALE:`Select a file then press ENTER, or SHIFT+${labelMETA()}+ENTER to insert at 100% scale.`,NO_MATCH:"No file matches your query.",SELECT_FILE_TO_LINK:"Select the file you want to insert the link for.",SELECT_DRAWING:"Select the image or drawing you want to insert",TYPE_FILENAME:"Type name of drawing to select.",SELECT_FILE_OR_TYPE_NEW:"Select existing drawing or type name of a new drawing then press Enter.",SELECT_TO_EMBED:"Select the drawing to insert into active document.",SELECT_MD:"Select the markdown document you want to insert",SELECT_PDF:"Select the PDF document you want to insert",PDF_PAGES_HEADER:"Pages to load?",PDF_PAGES_DESC:"Format: 1, 3-5, 7, 9-11",INFINITE_LOOP_WARNING:"EXCALIDRAW WARNING\nAborted loading embedded images due to infinite loop in file:\n",SCRIPT_EXECUTION_ERROR:"Script execution error. Please find error message on the developer console.",LOAD_FROM_BACKUP:"Excalidraw file was corrupted. Loading from backup file.",GOTO_FULLSCREEN:"Goto fullscreen mode",EXIT_FULLSCREEN:"Exit fullscreen mode",TOGGLE_FULLSCREEN:"Toggle fullscreen mode",TOGGLE_DISABLEBINDING:"Toggle to invert default binding behavior",OPEN_LINK_CLICK:"Navigate to selected element link",OPEN_LINK_PROPS:"Open markdown-embed properties or open link in new window",NARROW_TO_HEADING:"Narrow to heading...",NARROW_TO_BLOCK:"Narrow to block...",SHOW_ENTIRE_FILE:"Show entire file",ZOOM_TO_FIT:"Zoom to fit",RELOAD:"Reload original link",OPEN_IN_BROWSER:"Open current link in browser",PROMPT_FILE_DOES_NOT_EXIST:"File does not exist. Do you want to create it?",PROMPT_ERROR_NO_FILENAME:"Error: Filename for new file may not be empty",PROMPT_ERROR_DRAWING_CLOSED:"Unknown error. It seems as if your drawing was closed or the drawing file is missing",PROMPT_TITLE_NEW_FILE:"New File",PROMPT_TITLE_CONFIRMATION:"Confirmation",PROMPT_BUTTON_CREATE_EXCALIDRAW:"Create Excalidraw",PROMPT_BUTTON_CREATE_MARKDOWN:"Create Markdown",PROMPT_BUTTON_NEVERMIND:"Nevermind",PROMPT_BUTTON_OK:"OK",PROMPT_BUTTON_CANCEL:"Cancel",PROMPT_BUTTON_INSERT_LINE:"Insert new line",PROMPT_BUTTON_INSERT_SPACE:"Insert space",PROMPT_BUTTON_INSERT_LINK:"Insert markdown link to file",PROMPT_BUTTON_UPPERCASE:"Uppercase"},enGB={},es={},fr={},hi={},id={},it={},ja={},ko={},nl={},no={},pl={},pt={},ptBR={},ro={},ru={},tr={},zhCN={INSTALL_SCRIPT:"安装此脚本",UPDATE_SCRIPT:"有可用更新 - 点击安装",CHECKING_SCRIPT:"检查更新中 - 点击重新安装",UNABLETOCHECK_SCRIPT:"检查更新失败 - 点击重新安装",UPTODATE_SCRIPT:"脚本已是最新 - 点击重新安装",OPEN_AS_EXCALIDRAW:"打开为 Excalidraw 绘图",TOGGLE_MODE:"在 Excalidraw 和 Markdown 模式之间切换",CONVERT_NOTE_TO_EXCALIDRAW:"转换空白笔记为 Excalidraw 绘图",CONVERT_EXCALIDRAW:"转换 *.excalidraw 为 *.md 文件",CREATE_NEW:"新建 Excalidraw 绘图",CONVERT_FILE_KEEP_EXT:"*.excalidraw => *.excalidraw.md",CONVERT_FILE_REPLACE_EXT:"*.excalidraw => *.md (兼容 Logseq)",DOWNLOAD_LIBRARY:"导出 stencil 库为 *.excalidrawlib 文件",OPEN_EXISTING_NEW_PANE:"打开已有的绘图 - 于新面板",OPEN_EXISTING_ACTIVE_PANE:"打开已有的绘图 - 于当前面板",TRANSCLUDE:"嵌入绘图（形如 ![[drawing]]）到当前文档",TRANSCLUDE_MOST_RECENT:"嵌入最近编辑过的绘图（形如 ![[drawing]]）到当前文档",TOGGLE_LEFTHANDED_MODE:"切换为左手模式",NEW_IN_NEW_PANE:"新建绘图 - 于新面板",NEW_IN_NEW_TAB:"新建绘图 - 于新页签",NEW_IN_ACTIVE_PANE:"新建绘图 - 于当前面板",NEW_IN_POPOUT_WINDOW:"新建绘图 - 于新窗口",NEW_IN_NEW_PANE_EMBED:"新建绘图 - 于新面板 - 并将其嵌入（形如 ![[drawing]]）到当前文档",NEW_IN_NEW_TAB_EMBED:"新建绘图 - 于新页签 - 并将其嵌入（形如 ![[drawing]]）到当前文档",NEW_IN_ACTIVE_PANE_EMBED:"新建绘图 - 于当前面板 - 并将其嵌入（形如 ![[drawing]]）到当前文档",NEW_IN_POPOUT_WINDOW_EMBED:"新建绘图 - 于新窗口 - 并将其嵌入（形如 ![[drawing]]）到当前文档",EXPORT_SVG:"导出 SVG 文件到当前目录",EXPORT_PNG:"导出 PNG 文件到当前目录",EXPORT_SVG_WITH_SCENE:"导出 SVG 文件（包含 Scene）到当前目录",EXPORT_PNG_WITH_SCENE:"导出 PNG 文件（包含 Scene）到当前目录",TOGGLE_LOCK:"文本元素：原文模式（RAW）⟺ 预览模式（PREVIEW）",DELETE_FILE:"从库中删除所选图像（或 MD-Embed）的源文件",INSERT_LINK_TO_ELEMENT:`复制所选元素的内部链接（形如 [[file#^elementID]]）。\n按住 ${labelCTRL()} 可复制元素所在分组的内部链接（形如 [[file#^group=elementID]]）。\n按住 SHIFT 可复制所选元素周围区域的内部链接（形如 [[file#^area=elementID]]）。\n按住 ${labelALT()} 可观看视频演示。`,INSERT_LINK_TO_ELEMENT_GROUP:"复制所选元素所在分组的内部链接（形如 [[file#^group=elementID]]）",INSERT_LINK_TO_ELEMENT_AREA:"复制所选元素周围区域的内部链接（形如 [[file#^area=elementID]]）",INSERT_LINK_TO_ELEMENT_NORMAL:"复制所选元素的内部链接（形如 [[file#^elementID]]）",INSERT_LINK_TO_ELEMENT_ERROR:"未选择画布里的单个元素",INSERT_LINK_TO_ELEMENT_READY:"链接已生成并复制到剪贴板",INSERT_LINK:"插入文件的内部链接（形如 [[drawing]]）到当前绘图",INSERT_IMAGE:"插入图像（以图像形式嵌入）到当前绘图",IMPORT_SVG:"插入 SVG 矢量图形到当前绘图（支持有限，尚不支持文本）",INSERT_MD:"插入 Markdown 文档（以图像形式嵌入）到当前绘图",INSERT_LATEX:`插入 LaTeX 公式到当前绘图。按住 ${labelALT()} 可观看视频演示。`,ENTER_LATEX:"输入 LaTeX 表达式",READ_RELEASE_NOTES:"阅读本插件的更新说明",RUN_OCR:"OCR 识别涂鸦和图片里的文本并复制到剪贴板",TRAY_MODE:"绘图工具属性页：面板模式 ⟺ 托盘模式",SEARCH:"搜索文本",RESET_IMG_TO_100:"重设图像元素的尺寸为 100%",TEMPORARY_DISABLE_AUTOSAVE:"临时禁用自动保存功能，直到 Obsidian 退出（勿点，除非你清楚自己在干什么）",TEMPORARY_ENABLE_AUTOSAVE:"恢复启用自动保存功能",INSTALL_SCRIPT_BUTTON:"安装或更新 Excalidraw 脚本",OPEN_AS_MD:"打开为 Markdown 文件",SAVE_AS_PNG:`导出 PNG 到当前目录（按住 ${labelCTRL()} 设定导出路径；按住 SHIFT 在导出时包含 Scene）`,SAVE_AS_SVG:`导出 SVG 到当前目录（按住 ${labelCTRL()} 设定导出路径；按住 SHIFT 在导出时包含 Scene）`,OPEN_LINK:"打开所选元素里的链接 \n（按住 SHIFT 在新面板打开）",EXPORT_EXCALIDRAW:"导出为 .Excalidraw 文件",LINK_BUTTON_CLICK_NO_TEXT:"请选择一个含有链接的图形或文本元素。",FILENAME_INVALID_CHARS:'文件名不能含有以下符号： * " \\ < > : | ? #',FORCE_SAVE:"保存绘图（并更新嵌入了该绘图的面板）",RAW:"文本元素正以原文（RAW）模式显示链接。\n点击切换到预览（PREVIEW）模式",PARSED:"文本元素正以预览（PREVIEW）模式显示链接。\n点击切换到原文（RAW）模式",NOFILE:"Excalidraw（没有文件）",COMPATIBILITY_MODE:"*.excalidraw 文件正以兼容模式打开。需要转换为新格式才能使用插件的全部功能。",CONVERT_FILE:"转换为新格式",RELEASE_NOTES_NAME:"显示更新说明",RELEASE_NOTES_DESC:"开启：每次更新本插件后，显示最新发行版本的说明。
关闭：您仍可以在 GitHub 上阅读更新说明。",NEWVERSION_NOTIFICATION_NAME:"通知插件更新",NEWVERSION_NOTIFICATION_DESC:"开启：当本插件存在可用更新时，显示通知。
关闭：您需要手动检查本插件的更新（设置 - 第三方插件 - 检查更新）。",FOLDER_NAME:"Excalidraw 文件夹",FOLDER_DESC:"新绘图的默认存储路径。若为空，将在库的根目录中创建新绘图。",FOLDER_EMBED_NAME:"将 Excalidraw 文件夹用于“新建绘图”命令创建的绘图",FOLDER_EMBED_DESC:"在命令面板中执行“新建绘图”系列命令时，新绘图的存储路径。
开启：使用 Excalidraw 文件夹。
关闭：使用 Obsidian 设置的新附件默认位置。",TEMPLATE_NAME:"Excalidraw 模板文件",TEMPLATE_DESC:"Excalidraw 模板文件的完整路径。
如果您的模板在默认的 Excalidraw 文件夹中且文件名是 Template.md，则此项应设为 Excalidraw/Template.md（也可省略 .md 扩展名，即 Excalidraw/Template）。
如果您在兼容模式下使用 Excalidraw，那么您的模板文件也必须是旧的 *.excalidraw 格式，例如 Excalidraw/Template.excalidraw。",SCRIPT_FOLDER_NAME:"Excalidraw 自动化脚本的文件夹（大小写敏感！）",SCRIPT_FOLDER_DESC:"此文件夹用于存放 Excalidraw 自动化脚本。您可以在 Obsidian 命令面板中执行这些脚本，还可以为喜欢的脚本分配快捷键，就像为其他 Obsidian 命令分配快捷键一样。
该项不能设为库的根目录。",SAVING_HEAD:"保存",COMPRESS_NAME:"压缩 Excalidraw JSON",COMPRESS_DESC:"Excalidraw 绘图文件默认将元素记录为 JSON 格式。开启此项，可将元素的 JSON 数据以 BASE64 编码（使用 LZ-String 算法）。这样做的好处是：一方面可以避免原来的明文 JSON 数据干扰 Obsidian 的文本搜索结果，另一方面减小了绘图文件的体积。
当您通过功能区按钮或命令将绘图切换成 Markdown 模式时，数据将被解码回 JSON 格式以便阅读和编辑；而当您切换回 Excalidraw 模式时，数据就会被再次编码。
开启此项后，对于之前已存在的未压缩的绘图文件，需要重新打开并保存它们才能生效。",AUTOSAVE_INTERVAL_DESKTOP_NAME:"桌面端定期保存时间间隔",AUTOSAVE_INTERVAL_DESKTOP_DESC:"每隔多长时间触发一次自动保存。但如果当前绘图没有发生改变，将不会触发自动保存。当 Obsidian 应用内的焦点离开活动文档（如关闭工作空间、点击菜单栏、切换到其他页签或面板等）的时候，会触发自动保存。直接退出 Obsidian 应用（不管是终结进程还是点关闭按钮）不会触发自动保存。",AUTOSAVE_INTERVAL_MOBILE_NAME:"移动端定期保存时间间隔",AUTOSAVE_INTERVAL_MOBILE_DESC:"建议在移动端设置更短的自动保存时间间隔。当 Obsidian 应用内的焦点离开活动文档（如关闭工作空间、点击菜单栏、切换到其他页签或面板等）的时候，会触发自动保存。直接退出 Obsidian 应用（在应用切换器中划掉）不会触发自动保存。此外，当您切换到其他应用时，有时候系统会自动清理 Obsidian 后台以释放资源。这种情况下，Excalidraw 无法保存最新的变动。",FILENAME_HEAD:"文件名",FILENAME_DESC:"

点击阅读日期和时间格式参考。

",FILENAME_SAMPLE:"“新建绘图”系列命令创建的文件名形如：",FILENAME_EMBED_SAMPLE:"“新建绘图并嵌入到当前文档”系列命令创建的文件名形如：",FILENAME_PREFIX_NAME:"“新建绘图”系列命令创建的文件名前缀",FILENAME_PREFIX_DESC:"执行“新建绘图”系列命令时，创建的绘图文件名的第一部分",FILENAME_PREFIX_EMBED_NAME:"“新建绘图并嵌入到当前文档”系列命令创建的文件名前缀",FILENAME_PREFIX_EMBED_DESC:"执行“新建绘图并嵌入到当前文档”系列命令时，创建的绘图文件名是否以当前文档名作为前缀？
开启：是
关闭：否",FILENAME_POSTFIX_NAME:"“新建绘图并嵌入到当前文档”系列命令创建的文件名的中间部分",FILENAME_POSTFIX_DESC:"介于文件名前缀和日期时间之间的文本。仅对“新建绘图并嵌入到当前文档”系列命令创建的绘图生效。",FILENAME_DATE_NAME:"文件名里的日期时间",FILENAME_DATE_DESC:"文件名的最后一部分。允许留空。",FILENAME_EXCALIDRAW_EXTENSION_NAME:"文件扩展名（.excalidraw.md 或 .md）",FILENAME_EXCALIDRAW_EXTENSION_DESC:"该选项在兼容模式（即非 Excalidraw 专用 Markdown 文件）下不会生效。
开启：使用 .excalidraw.md 作为扩展名。
关闭：使用 .md 作为扩展名。",DISPLAY_HEAD:"显示",LEFTHANDED_MODE_NAME:"左手模式",LEFTHANDED_MODE_DESC:"目前只在托盘模式下生效。若开启此项，则托盘（绘图工具属性页）将位于右侧。
开启：左手模式。
关闭：右手模式。",MATCH_THEME_NAME:"使新建的绘图匹配 Obsidian 主题",MATCH_THEME_DESC:"如果 Obsidian 使用黑暗主题，新建的绘图文件也将使用黑暗主题。
但是若设置了模板，新建的绘图文件将跟随模板主题；另外，此功能不会作用于已有的绘图。
开启：跟随 Obsidian 主题风格。
关闭：跟随模板主题风格。",MATCH_THEME_ALWAYS_NAME:"使已有的绘图匹配 Obsidian 主题",MATCH_THEME_ALWAYS_DESC:"如果 Obsidian 使用黑暗主题，则绘图文件也将以黑暗主题打开；反之亦然。
开启：匹配 Obsidian 主题风格。
关闭：采用上次保存时的主题风格。",MATCH_THEME_TRIGGER_NAME:"Excalidraw 主题跟随 Obsidian 主题变化",MATCH_THEME_TRIGGER_DESC:"开启此项，则切换 Obsidian 的黑暗/明亮主题时，已打开的 Excalidraw 面板的主题会随之改变。
开启：跟随主题变化。
关闭：不跟随主题变化。",DEFAULT_OPEN_MODE_NAME:"Excalidraw 的默认运行模式",DEFAULT_OPEN_MODE_DESC:"设置 Excalidraw 的运行模式：普通模式（Normal）/禅模式（Zen）/阅读模式（View）。
您可为某个绘图单独设置此项，方法是在其 frontmatter 中添加形如 excalidraw-default-mode: normal/zen/view 的键值对。",DEFAULT_PEN_MODE_NAME:"触控笔模式（Pen mode）",DEFAULT_PEN_MODE_DESC:"打开绘图时，是否自动开启触控笔模式？",DEFAULT_PINCHZOOM_NAME:"允许在触控笔模式下进行双指缩放",DEFAULT_PINCHZOOM_DESC:"在触控笔模式下使用自由画笔工具时，双指缩放可能造成干扰。
开启: 允许在触控笔模式下进行双指缩放
关闭： 禁止在触控笔模式下进行双指缩放",DEFAULT_WHEELZOOM_NAME:"鼠标滚轮缩放页面",DEFAULT_WHEELZOOM_DESC:`开启：鼠标滚轮为缩放页面，${labelCTRL()}+鼠标滚轮为滚动页面
关闭：鼠标滚轮为滚动页面，${labelCTRL()}+鼠标滚轮为缩放页面`,ZOOM_TO_FIT_NAME:"调节面板尺寸后自动缩放页面",ZOOM_TO_FIT_DESC:"调节面板尺寸后，自适应地缩放页面
开启：自动缩放。
关闭：禁用自动缩放。",ZOOM_TO_FIT_ONOPEN_NAME:"打开绘图时自动缩放页面",ZOOM_TO_FIT_ONOPEN_DESC:"打开绘图文件时，自适应地缩放页面
开启：自动缩放。
关闭：禁用自动缩放。",ZOOM_TO_FIT_MAX_LEVEL_NAME:"自动缩放的最高级别",ZOOM_TO_FIT_MAX_LEVEL_DESC:"自动缩放画布时，允许放大的最高级别。该值不能低于 0.5（50%）且不能超过 10（1000%）。",LINKS_HEAD:"链接（Links） & 以文本形式嵌入到绘图中的文档（Transclusion）",LINKS_DESC:`按住 ${labelCTRL()} 并点击包含 [[链接]] 的文本元素可以打开其中的链接。如果所选文本元素包含多个 [[有效的内部链接]] ，只会打开第一个链接；如果所选文本元素包含有效的 URL 链接 (如 https:// 或 http://)，插件会在浏览器中打开链接。
链接的源文件被重命名时，绘图中相应的 [[内部链接]] 也会同步更新。若您不愿绘图中的链接外观因此而变化，可使用 [[内部链接|别名]]。`,ADJACENT_PANE_NAME:"在相邻面板中打开",ADJACENT_PANE_DESC:`按住 ${labelCTRL()}+SHIFT 并点击绘图里的内部链接时，插件默认会在新面板中打开该链接。
若开启此项，Excalidraw 会先尝试寻找已有的相邻面板（按照右侧、左侧、上方、下方的顺序），并在其中打开该链接。如果找不到，再在新面板中打开。`,MAINWORKSPACE_PANE_NAME:"在主工作区中打开",MAINWORKSPACE_PANE_DESC:`按住 ${labelCTRL()}+SHIFT 并点击绘图里的内部链接时，插件默认会在当前窗口的新面板中打开该链接。
若开启此项，Excalidraw 会在主工作区的面板中打开该链接。`,LINK_BRACKETS_NAME:"在链接的两侧显示 [[中括号]]",LINK_BRACKETS_DESC:"文本元素处于预览（PREVIEW）模式时，在内部链接的两侧显示中括号。
您可为某个绘图单独设置此项，方法是在其 frontmatter 中添加形如 excalidraw-link-brackets: true/false 的键值对。",LINK_PREFIX_NAME:"内部链接的前缀",LINK_PREFIX_DESC:'文本元素处于预览（PREVIEW）模式时，如果其中包含链接，则添加此前缀。
您可为某个绘图单独设置此项，方法是在其 frontmatter 中添加形如 excalidraw-link-prefix: "📍 " 的键值对。',URL_PREFIX_NAME:"外部链接的前缀",URL_PREFIX_DESC:'文本元素处于预览（PREVIEW）模式时，如果其中包含外部链接，则添加此前缀。
您可为某个绘图单独设置此项，方法是在其 frontmatter 中添加形如 excalidraw-url-prefix: "🌐 " 的键值对。',PARSE_TODO_NAME:"待办任务（Todo）",PARSE_TODO_DESC:"将文本元素中的 - [ ] 和 - [x] 前缀显示为方框。",TODO_NAME:"未完成项目",TODO_DESC:"未完成的待办项目的符号",DONE_NAME:"已完成项目",DONE_DESC:"已完成的待办项目的符号",HOVERPREVIEW_NAME:"鼠标悬停预览内部链接",HOVERPREVIEW_DESC:`开启：在 Excalidraw 阅读模式（View）下，鼠标悬停在 [[内部链接]] 上即可预览；而在普通模式（Normal）下, 鼠标悬停在内部链接右上角的蓝色标识上即可预览。
关闭：鼠标悬停在 [[内部链接]] 上，并且按住 ${labelCTRL()} 才能预览。`,LINKOPACITY_NAME:"链接标识的透明度",LINKOPACITY_DESC:"含有链接的元素，其右上角的链接标识的透明度。介于 0（全透明）到 1（不透明）之间。",LINK_CTRL_CLICK_NAME:`按住 ${labelCTRL()} 并点击含有 [[链接]] 或 [别名](链接) 的文本来打开链接`,LINK_CTRL_CLICK_DESC:"如果此功能影响到您使用某些原版 Excalidraw 功能，可将其关闭。关闭后，您只能通过绘图面板标题栏中的链接按钮来打开链接。",TRANSCLUSION_WRAP_NAME:"Transclusion 的折行方式",TRANSCLUSION_WRAP_DESC:"中的 number 表示嵌入的文本溢出时，在第几个字符处进行折行。
此开关控制具体的折行方式。若开启，则严格在 number 处折行，禁止溢出；若关闭，则允许在 number 位置后最近的空格处折行。",TRANSCLUSION_DEFAULT_WRAP_NAME:"Transclusion 的默认折行位置",TRANSCLUSION_DEFAULT_WRAP_DESC:"除了通过 ![[doc#^block]]{number} 中的 number 来控制折行位置，您也可以在此设置 number 的默认值。
一般设为 0 即可，表示不设置固定的默认值，这样当您需要嵌入文档到便签中时，Excalidraw 能更好地帮您自动处理。",PAGE_TRANSCLUSION_CHARCOUNT_NAME:"Transclusion 的最大显示字符数",PAGE_TRANSCLUSION_CHARCOUNT_DESC:"以 ![[内部链接]] 或 ![](内部链接) 的形式将文档以文本形式嵌入到绘图中时，该文档在绘图中可显示的最大字符数量。",QUOTE_TRANSCLUSION_REMOVE_NAME:"隐藏 Transclusion 行首的引用符号",QUOTE_TRANSCLUSION_REMOVE_DESC:"不显示 Transclusion 中每一行行首的 > 符号，以提高纯文本 Transclusion 的可读性。
开启：隐藏 > 符号
关闭：不隐藏 > 符号（注意，由于 Obsidian API 的原因，首行行首的 > 符号不会被隐藏）",GET_URL_TITLE_NAME:"使用 iframly 获取页面标题",GET_URL_TITLE_DESC:"拖放链接到 Excalidraw 时，使用 http://iframely.server.crestify.com/iframely?url= 来获取页面的标题。",MD_HEAD:"以图像形式嵌入到绘图中的 Markdown 文档（MD-Embed）",MD_HEAD_DESC:`您还可以将 Markdown 文档以图像形式（而非文本形式）嵌入到绘图中。方法是按住 ${labelCTRL()} 并从文件管理器中把文档拖入绘图，或者执行“以图像形式嵌入”系列命令。`,MD_TRANSCLUDE_WIDTH_NAME:"MD-Embed 的默认宽度",MD_TRANSCLUDE_WIDTH_DESC:"MD-Embed 的宽度。该选项会影响到折行，以及图像元素的宽度。
您可为绘图中的某个 MD-Embed 单独设置此项，方法是将绘图切换至 Markdown 模式，并修改相应的 [[Embed文件名#标题|宽度x最大高度]]。",MD_TRANSCLUDE_HEIGHT_NAME:"MD-Embed 的默认最大高度",MD_TRANSCLUDE_HEIGHT_DESC:"MD-Embed 的高度取决于 Markdown 文档内容的多少，但最大不会超过该值。
您可为绘图中的某个 MD-Embed 单独设置此项，方法是将绘图切换至 Markdown 模式，并修改相应的 [[Embed文件名#^块引ID|宽度x最大高度]]。",MD_DEFAULT_FONT_NAME:"MD-Embed 的默认字体",MD_DEFAULT_FONT_DESC:"可以设为 Virgil，Casadia 或其他有效的 .ttf/.woff/.woff2 字体文件（如 我的字体.woff2）。
您可为某个 MD-Embed 单独设置此项，方法是在其源文件的 frontmatter 中添加形如 excalidraw-font: 字体名或文件名 的键值对。",MD_DEFAULT_COLOR_NAME:"MD-Embed 的默认文本颜色",MD_DEFAULT_COLOR_DESC:"可以填写 HTML 颜色名，如 steelblue（参考 HTML Color Names），或者有效的 16 进制颜色值，例如 #e67700，或者任何其他有效的 CSS 颜色。
您可为某个 MD-Embed 单独设置此项，方法是在其源文件的 frontmatter 中添加形如 excalidraw-font-color: steelblue 的键值对。",MD_DEFAULT_BORDER_COLOR_NAME:"MD-Embed 的默认边框颜色",MD_DEFAULT_BORDER_COLOR_DESC:"可以填写 HTML 颜色名，如 steelblue（参考 HTML Color Names），或者有效的 16 进制颜色值，例如 #e67700，或者任何其他有效的 CSS 颜色。
您可为某个 MD-Embed 单独设置此项，方法是在其源文件的 frontmatter 中添加形如 excalidraw-border-color: gray 的键值对。
如果您不想要边框，请留空。",MD_CSS_NAME:"MD-Embed 的默认 CSS 样式表",MD_CSS_DESC:"MD-Embed 图像所采用的 CSS 样式表文件名。需包含扩展名，例如 md-embed.css。允许使用 Markdown 文件（如 md-embed-css.md），但其内容应符合 CSS 语法。
如果您要查询 CSS 所作用的 HTML 节点，请在 Obsidian 开发者控制台（CTRL+SHIFT+i）中键入命令：ExcalidrawAutomate.mostRecentMarkdownSVG —— 这将显示 Excalidraw 最近生成的 SVG。
此外，在 CSS 中不能任意地设置字体，您一般只能使用系统默认的标准字体（详见 README），但可以通过上面的设置来额外添加一个自定义字体。
您可为某个 MD-Embed 单独设置此项，方法是在其源文件的 frontmatter 中添加形如 excalidraw-css: 库中的CSS文件或CSS片段 的键值对。",EMBED_HEAD:"嵌入到文档中的绘图（Embed） & 导出",EMBED_REUSE_EXPORTED_IMAGE_NAME:"将之前已导出的图像作为 Embed 的预览图（如果存在的话）",EMBED_REUSE_EXPORTED_IMAGE_DESC:"该选项与“自动导出 SVG/PNG 副本”选项配合使用。如果存在文件名相匹配的 SVG/PNG 副本，则将其作为 Embed 的预览图，而不再重新生成预览图。
该选项能够提高性能，尤其是当 Embed 中含有大量图像或 MD-Embed 时。但是，该选项也可能导致预览图无法立即响应你最新的修改，或者你对 Obsidian 主题风格的改变。
该选项仅作用于嵌入到文档中的绘图。由于种种原因，该技术无法用于加快绘图文件的打开速度。详见此说明。",EMBED_PREVIEW_SVG_NAME:"生成 SVG 格式的 Embed 预览图",EMBED_PREVIEW_SVG_DESC:"开启：在 Markdown 预览模式下，为 Embed 生成 SVG 格式的预览图。
关闭：为 Embed 生成 PNG 格式的预览图。注意：PNG 格式预览图不支持某些 绘图元素的块引用特性。",PREVIEW_MATCH_OBSIDIAN_NAME:"Embed 预览图匹配 Obsidian 主题",PREVIEW_MATCH_OBSIDIAN_DESC:"开启此项，则当 Obsidian 处于黑暗模式时，Embed 的预览图也会以黑暗模式渲染；当 Obsidian 处于明亮模式时，预览图也会以明亮模式渲染。
您可能还需要关闭“导出的图像包含背景”开关，来获得与 Obsidian 更加协调的观感。",EMBED_WIDTH_NAME:"Embed 预览图的默认宽度",EMBED_WIDTH_DESC:"该选项同时作用于 Obsidian 实时预览模式下的编辑视图和阅读视图，以及鼠标悬停时浮现的预览图。
您可为某个要嵌入到文档中的绘图（Embed）单独设置此项，方法是修改相应的链接格式为形如 ![[drawing.excalidraw|100]] 或 [[drawing.excalidraw|100x100]] 的格式。",EMBED_TYPE_NAME:"“嵌入绘图到当前文档”系列命令的源文件类型",EMBED_TYPE_DESC:"在命令面板中执行“嵌入绘图到当前文档”系列命令时，要嵌入绘图文件本身，还是嵌入其 PNG 或 SVG 副本。
如果您想选择 PNG 或 SVG 副本，需要先开启下方的“自动导出 PNG 副本”或“自动导出 SVG 副本”开关。
如果您选择了 PNG 或 SVG 副本，当副本不存在时，该命令将会插入一条损坏的链接，您需要打开绘图文件并手动导出副本才能修复 —— 也就是说，该选项不会自动帮您生成 PNG/SVG 副本，而只会引用已有的 PNG/SVG 副本。",EMBED_WIKILINK_NAME:"“嵌入绘图到当前文档”命令产生的内部链接类型",EMBED_WIKILINK_DESC:"开启：将产生 ![[Wiki 链接]]。关闭：将产生 ![](Markdown 链接)。",EXPORT_PNG_SCALE_NAME:"导出的 PNG 图像的比例",EXPORT_PNG_SCALE_DESC:"导出的 PNG 图像的大小比例",EXPORT_BACKGROUND_NAME:"导出的图像包含背景",EXPORT_BACKGROUND_DESC:"如果关闭，将导出透明背景的图像。",EXPORT_PADDING_NAME:"导出的图像的空白边距",EXPORT_PADDING_DESC:"导出的 SVG/PNG 图像四周的空白边距（单位：像素）。
增加该值，可以避免在导出图像时，靠近图像边缘的图形被裁掉。
您可为某个绘图单独设置此项，方法是在其 frontmatter 中添加形如 excalidraw-export-padding: 5 的键值对。",EXPORT_THEME_NAME:"导出的图像包含主题",EXPORT_THEME_DESC:"导出与绘图的黑暗/明亮主题匹配的图像。如果关闭，在黑暗主题下导出的图像将和明亮主题一样。",EXPORT_HEAD:"导出设置",EXPORT_SYNC_NAME:"保持 SVG/PNG 文件名与绘图文件同步",EXPORT_SYNC_DESC:"打开后，当绘图文件被重命名时，插件将同步更新同文件夹下的同名 .SVG 和 .PNG 文件。当绘图文件被删除时，插件将自动删除同文件夹下的同名 .SVG 和 .PNG 文件。",EXPORT_SVG_NAME:"自动导出 SVG 副本",EXPORT_SVG_DESC:"自动导出和绘图文件同名的 SVG 副本。插件会将副本保存到绘图文件所在的文件夹中。在文档中嵌入这个 SVG 文件，相比直接嵌入绘图文件，具有更强的跨平台能力。
此开关开启时，每次您编辑 Excalidraw 绘图，其 SVG 文件副本都会同步更新。
您可为某个绘图单独设置此项，方法是在其 frontmatter 中添加形如 excalidraw-autoexport: none/both/svg/png的键值对",EXPORT_PNG_NAME:"自动导出 PNG 副本",EXPORT_PNG_DESC:"和“自动导出 SVG 副本”类似，但是导出格式为 *.PNG。",EXPORT_BOTH_DARK_AND_LIGHT_NAME:"同时导出黑暗和明亮风格的图像",EXPORT_BOTH_DARK_AND_LIGHT_DESC:"若开启，Excalidraw 将导出两个文件：filename.dark.png（或 filename.dark.svg）和 filename.light.png（或 filename.light.svg）。
该选项可作用于“自动导出 SVG 副本”、“自动导出 PNG 副本”，以及其他的手动的导出命令。",COMPATIBILITY_HEAD:"兼容性设置",EXPORT_EXCALIDRAW_NAME:"自动导出 Excalidraw 旧格式副本",EXPORT_EXCALIDRAW_DESC:"和“自动导出 SVG 副本”类似，但是导出格式为 *.excalidraw。",SYNC_EXCALIDRAW_NAME:"新旧格式绘图文件的内容保持同步",SYNC_EXCALIDRAW_DESC:"如果旧格式（*.excalidraw）绘图文件的修改日期比新格式（*.md）更新，则根据旧格式文件的内容来更新新格式文件。",COMPATIBILITY_MODE_NAME:"以旧格式创建新绘图",COMPATIBILITY_MODE_DESC:"开启此功能后，您通过功能区按钮、命令面板、文件浏览器等创建的绘图都将是旧格式（*.excalidraw）。此外，您打开旧格式绘图文件时将不再收到提醒消息。",MATHJAX_NAME:"MathJax (LaTeX) 的 javascript 库服务器",MATHJAX_DESC:"如果您在绘图中使用 LaTeX，插件需要从服务器获取并加载一个 javascript 库。如果您的网络无法访问某些库服务器，可以尝试通过此选项更换库服务器。更改此选项后，您可能需要重启 Obsidian 来使其生效。",NONSTANDARD_HEAD:"非 Excalidraw.com 官方支持的特性",NONSTANDARD_DESC:"这些特性不受 Excalidraw.com 官方支持。当导出绘图到 Excalidraw.com 时，这些特性将会发生变化。",CUSTOM_PEN_NAME:"自定义画笔的数量",CUSTOM_PEN_DESC:"在画布上的 Obsidian 菜单旁边切换自定义画笔。长按画笔按钮可以修改其样式。",EXPERIMENTAL_HEAD:"实验性功能",EXPERIMENTAL_DESC:"以下部分设置不会立即生效，需要刷新文件资源管理器或者重启 Obsidian 才会生效。",FIELD_SUGGESTER_NAME:"开启字段建议",FIELD_SUGGESTER_DESC:"开启后，当您在编辑器中输入 excalidraw- 或者 ea. 时，会弹出一个带有函数说明的自动补全提示菜单。
该功能借鉴了 Breadcrumbs 和 Templater 插件。",FILETYPE_NAME:"在文件浏览器中为 excalidraw.md 文件添加类型标识符（如 ✏️）",FILETYPE_DESC:"可通过下一项设置来自定义类型标识符。",FILETAG_NAME:"excalidraw.md 文件的类型标识符",FILETAG_DESC:"要显示为类型标识符的 emoji 或文本。",INSERT_EMOJI:"插入 emoji",LIVEPREVIEW_NAME:"嵌入绘图到文档时，模拟嵌入图像的语法",LIVEPREVIEW_DESC:"开启此项，则可在 Obsidian 实时预览模式的编辑视图下，用形如 ![[绘图|宽度|样式]] 的语法来嵌入绘图。
该选项不会在已打开的文档中立刻生效 —— 你需要重新打开此文档来使其生效。",ENABLE_FOURTH_FONT_NAME:"为文本元素启用本地字体",ENABLE_FOURTH_FONT_DESC:"开启此项后，文本元素的属性面板里会多出一个本地字体按钮。
使用了本地字体的绘图文件，将会失去一部分跨平台能力 —— 若将绘图文件移动到其他库中打开，显示效果可能会截然不同；若在 excalidraw.com 或者其他版本的 Excalidraw 中打开，使用本地字体的文本会变回系统默认字体。",FOURTH_FONT_NAME:"本地字体文件",FOURTH_FONT_DESC:"选择库文件夹中的一个 .ttf, .woff 或 .woff2 字体文件作为本地字体文件。若未选择文件，则使用默认的 Virgil 字体。",SCRIPT_SETTINGS_HEAD:"已安装脚本的设置",TASKBONE_HEAD:"Taskbone OCR（光学符号识别）",TASKBONE_DESC:"这是一个将 OCR 融入 Excalidraw 的实验性功能。请注意，Taskbone 是一项独立的外部服务，而不是由 Excalidraw 或 Obsidian-excalidraw-plugin 项目提供的。OCR 能够对画布上用自由画笔工具写下的涂鸦或者嵌入的图像进行文本识别，并将识别出来的文本写入绘图文件的 frontmatter，同时复制到剪贴板。之所以要写入 frontmatter 是为了便于您在 Obsidian 中能够搜索到这些文本。注意，识别的过程不是在本地进行的，而是通过在线 API，图像会被上传到 taskbone 的服务器（仅用于识别目的）。如果您对此敏感，请不要使用这个功能。",TASKBONE_ENABLE_NAME:"启用 Taskbone",TASKBONE_ENABLE_DESC:"启用这个功能意味着你同意 Taskbone 条款及细则 以及 隐私政策.",TASKBONE_APIKEY_NAME:"Taskbone API Key",TASKBONE_APIKEY_DESC:"Taskbone 的免费 API key 提供了一定数量的每月识别次数。如果您非常频繁地使用此功能，或者想要支持 Taskbone 的开发者（您懂的，没有人能用爱发电，Taskbone 开发者也需要投入资金才能持续运行这项 OCR 服务）您可以到 taskbone.com 购买一个商用 API key。购买后请将它填写到旁边这个文本框里，替换掉原本自动生成的免费 API key。",SELECT_FILE:"选择一个文件后按回车。",SELECT_FILE_WITH_OPTION_TO_SCALE:`选择一个文件后按回车，或者 SHIFT+${labelMETA()}+ENTER 以 100% 尺寸插入。`,NO_MATCH:"查询不到匹配的文件。",SELECT_FILE_TO_LINK:"选择要插入（链接）到当前绘图中的文件。",SELECT_DRAWING:"选择要插入（以图像形式嵌入）到当前绘图中的图像。",TYPE_FILENAME:"键入要选择的绘图名称。",SELECT_FILE_OR_TYPE_NEW:"选择已有绘图，或者新绘图的类型，然后按回车。",SELECT_TO_EMBED:"选择要插入（嵌入）到当前文档中的绘图。",SELECT_MD:"选择要插入（以图像形式嵌入）到当前绘图中的 Markdown 文档。",INFINITE_LOOP_WARNING:"EXCALIDRAW 警告\n停止加载嵌入的图像，因为此文件中存在死循环：\n",SCRIPT_EXECUTION_ERROR:"脚本运行错误。请在开发者控制台中查看错误信息。",LOAD_FROM_BACKUP:"Excalidraw 文件已损坏。尝试从备份文件中加载。",GOTO_FULLSCREEN:"进入全屏模式",EXIT_FULLSCREEN:"退出全屏模式",TOGGLE_FULLSCREEN:"切换全屏模式",OPEN_LINK_CLICK:"打开所选的图形或文本元素里的链接",OPEN_LINK_PROPS:"编辑所选 MD-Embed 的内部链接，或者打开所选的图形或文本元素里的链接"},zhTW={};const localeMap={ar:ar,cs:cz,da:da,de:de,en:en,"en-gb":enGB,es:es,fr:fr,hi:hi,id:id,it:it,ja:ja,ko:ko,nl:nl,nn:no,pl:pl,pt:pt,"pt-br":ptBR,ro:ro,ru:ru,tr:tr,"zh-cn":zhCN,"zh-tw":zhTW},locale=localeMap[obsidian_module.moment.locale()];function t$d(e){return locale||errorlog({where:"helpers.t",message:"Error: Excalidraw locale not found",locale:obsidian_module.moment.locale()}),locale&&locale[e]||en[e]}var html2canvasExports={},html2canvas$1={get exports(){return html2canvasExports},set exports(e){html2canvasExports=e}};html2canvas$1.exports=function(){ +/*! ***************************************************************************** + Copyright (c) Microsoft Corporation. + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted. + + THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH + REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, + INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM + LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR + OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + PERFORMANCE OF THIS SOFTWARE. + ***************************************************************************** */ +var e=function(t,A){return e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var A in t)Object.prototype.hasOwnProperty.call(t,A)&&(e[A]=t[A])},e(t,A)};function t(t,A){if("function"!=typeof A&&null!==A)throw new TypeError("Class extends value "+String(A)+" is not a constructor or null");function i(){this.constructor=t}e(t,A),t.prototype=null===A?Object.create(A):(i.prototype=A.prototype,new i)}var A=function(){return A=Object.assign||function(e){for(var t,A=1,i=arguments.length;A0&&n[n.length-1])||6!==a[0]&&2!==a[0])){r=0;continue}if(3===a[0]&&(!n||a[1]>n[0]&&a[1]=55296&&n<=56319&&A>10),r%1024+56320)),(n+1===A||i.length>16384)&&(a+=String.fromCharCode.apply(String,i),i.length=0)}return a},c="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",d="undefined"==typeof Uint8Array?[]:new Uint8Array(256),h=0;h=0){if(e<55296||e>56319&&e<=65535)return t=((t=this.index[e>>5])<<2)+(31&e),this.data[t];if(e<=65535)return t=((t=this.index[2048+(e-55296>>5)])<<2)+(31&e),this.data[t];if(e>11),t=this.index[t],t+=e>>5&63,t=((t=this.index[t])<<2)+(31&e),this.data[t];if(e<=1114111)return this.data[this.highValueIndex]}return this.errorValue},e}(),f="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",E="undefined"==typeof Uint8Array?[]:new Uint8Array(256),B=0;B>4,c[o++]=(15&i)<<4|n>>2,c[o++]=(3&n)<<6|63&a;return l}(e),i=Array.isArray(A)?function(e){for(var t=e.length,A=[],i=0;i0;){var r=i[--a];if(Array.isArray(e)?-1!==e.indexOf(r):e===r)for(var s=A;s<=i.length;){var o;if((o=i[++s])===t)return!0;if(o!==b)break}if(r!==b)break}return!1},ie=function(e,t){for(var A=e;A>=0;){var i=t[A];if(i!==b)return i;A--}return 0},ne=function(e,t,A,i,n){if(0===A[i])return X;var a=i-1;if(Array.isArray(n)&&!0===n[a])return X;var r=a-1,s=a+1,o=t[a],l=r>=0?t[r]:0,c=t[s];if(2===o&&3===c)return X;if(-1!==J.indexOf(o))return"!";if(-1!==J.indexOf(c))return X;if(-1!==Z.indexOf(c))return X;if(8===ie(a,t))return Y;if(11===j.get(e[a]))return X;if((o===N||o===D)&&11===j.get(e[s]))return X;if(7===o||7===c)return X;if(9===o)return X;if(-1===[b,v,C].indexOf(o)&&9===c)return X;if(-1!==[y,F,x,k,L].indexOf(c))return X;if(ie(a,t)===I)return X;if(Ae(23,I,a,t))return X;if(Ae([y,F],T,a,t))return X;if(Ae(12,12,a,t))return X;if(o===b)return Y;if(23===o||23===c)return X;if(16===c||16===o)return Y;if(-1!==[v,C,T].indexOf(c)||14===o)return X;if(36===l&&-1!==te.indexOf(o))return X;if(o===L&&36===c)return X;if(c===S)return X;if(-1!==_.indexOf(c)&&o===U||-1!==_.indexOf(o)&&c===U)return X;if(o===O&&-1!==[P,N,D].indexOf(c)||-1!==[P,N,D].indexOf(o)&&c===Q)return X;if(-1!==_.indexOf(o)&&-1!==q.indexOf(c)||-1!==q.indexOf(o)&&-1!==_.indexOf(c))return X;if(-1!==[O,Q].indexOf(o)&&(c===U||-1!==[I,C].indexOf(c)&&t[s+1]===U)||-1!==[I,C].indexOf(o)&&c===U||o===U&&-1!==[U,L,k].indexOf(c))return X;if(-1!==[U,L,k,y,F].indexOf(c))for(var d=a;d>=0;){if((h=t[d])===U)return X;if(-1===[L,k].indexOf(h))break;d--}if(-1!==[O,Q].indexOf(c))for(d=-1!==[y,F].indexOf(o)?r:a;d>=0;){var h;if((h=t[d])===U)return X;if(-1===[L,k].indexOf(h))break;d--}if(V===o&&-1!==[V,K,R,H].indexOf(c)||-1!==[K,R].indexOf(o)&&-1!==[K,G].indexOf(c)||-1!==[G,H].indexOf(o)&&c===G)return X;if(-1!==ee.indexOf(o)&&-1!==[S,Q].indexOf(c)||-1!==ee.indexOf(c)&&o===O)return X;if(-1!==_.indexOf(o)&&-1!==_.indexOf(c))return X;if(o===k&&-1!==_.indexOf(c))return X;if(-1!==_.concat(U).indexOf(o)&&c===I&&-1===z.indexOf(e[s])||-1!==_.concat(U).indexOf(c)&&o===F)return X;if(41===o&&41===c){for(var u=A[a],g=1;u>0&&41===t[--u];)g++;if(g%2!=0)return X}return o===N&&c===D?X:Y},ae=function(e,t){t||(t={lineBreak:"normal",wordBreak:"normal"});var A=function(e,t){void 0===t&&(t="strict");var A=[],i=[],n=[];return e.forEach((function(e,a){var r=j.get(e);if(r>50?(n.push(!0),r-=50):n.push(!1),-1!==["normal","auto","loose"].indexOf(t)&&-1!==[8208,8211,12316,12448].indexOf(e))return i.push(a),A.push(16);if(4===r||11===r){if(0===a)return i.push(a),A.push(M);var s=A[a-1];return-1===$.indexOf(s)?(i.push(i[a-1]),A.push(s)):(i.push(a),A.push(M))}return i.push(a),31===r?A.push("strict"===t?T:P):r===W||29===r?A.push(M):43===r?e>=131072&&e<=196605||e>=196608&&e<=262141?A.push(P):A.push(M):void A.push(r)})),[i,A,n]}(e,t.lineBreak),i=A[0],n=A[1],a=A[2];"break-all"!==t.wordBreak&&"break-word"!==t.wordBreak||(n=n.map((function(e){return-1!==[U,M,W].indexOf(e)?P:e})));var r="keep-all"===t.wordBreak?a.map((function(t,A){return t&&e[A]>=19968&&e[A]<=40959})):void 0;return[i,n,r]},re=function(){function e(e,t,A,i){this.codePoints=e,this.required="!"===t,this.start=A,this.end=i}return e.prototype.slice=function(){return l.apply(void 0,this.codePoints.slice(this.start,this.end))},e}(),se=45,oe=43,le=-1,ce=function(e){return e>=48&&e<=57},de=function(e){return ce(e)||e>=65&&e<=70||e>=97&&e<=102},he=function(e){return 10===e||9===e||32===e},ue=function(e){return function(e){return function(e){return e>=97&&e<=122}(e)||function(e){return e>=65&&e<=90}(e)}(e)||function(e){return e>=128}(e)||95===e},ge=function(e){return ue(e)||ce(e)||e===se},pe=function(e){return e>=0&&e<=8||11===e||e>=14&&e<=31||127===e},me=function(e,t){return 92===e&&10!==t},we=function(e,t,A){return e===se?ue(t)||me(t,A):!!ue(e)||!(92!==e||!me(e,t))},fe=function(e,t,A){return e===oe||e===se?!!ce(t)||46===t&&ce(A):ce(46===e?t:e)},Ee=function(e){var t=0,A=1;e[t]!==oe&&e[t]!==se||(e[t]===se&&(A=-1),t++);for(var i=[];ce(e[t]);)i.push(e[t++]);var n=i.length?parseInt(l.apply(void 0,i),10):0;46===e[t]&&t++;for(var a=[];ce(e[t]);)a.push(e[t++]);var r=a.length,s=r?parseInt(l.apply(void 0,a),10):0;69!==e[t]&&101!==e[t]||t++;var o=1;e[t]!==oe&&e[t]!==se||(e[t]===se&&(o=-1),t++);for(var c=[];ce(e[t]);)c.push(e[t++]);var d=c.length?parseInt(l.apply(void 0,c),10):0;return A*(n+s*Math.pow(10,-r))*Math.pow(10,o*d)},Be={type:2},be={type:3},ve={type:4},Ce={type:13},ye={type:8},Fe={type:21},xe={type:9},Se={type:10},Te={type:11},Ie={type:12},ke={type:14},Ue={type:23},Qe={type:1},Oe={type:25},Le={type:24},Me={type:26},Ne={type:27},De={type:28},Re={type:29},He={type:31},Pe={type:32},Ve=function(){function e(){this._value=[]}return e.prototype.write=function(e){this._value=this._value.concat(o(e))},e.prototype.read=function(){for(var e=[],t=this.consumeToken();t!==Pe;)e.push(t),t=this.consumeToken();return e},e.prototype.consumeToken=function(){var e=this.consumeCodePoint();switch(e){case 34:return this.consumeStringToken(34);case 35:var t=this.peekCodePoint(0),A=this.peekCodePoint(1),i=this.peekCodePoint(2);if(ge(t)||me(A,i)){var n=we(t,A,i)?2:1;return{type:5,value:this.consumeName(),flags:n}}break;case 36:if(61===this.peekCodePoint(0))return this.consumeCodePoint(),Ce;break;case 39:return this.consumeStringToken(39);case 40:return Be;case 41:return be;case 42:if(61===this.peekCodePoint(0))return this.consumeCodePoint(),ke;break;case oe:if(fe(e,this.peekCodePoint(0),this.peekCodePoint(1)))return this.reconsumeCodePoint(e),this.consumeNumericToken();break;case 44:return ve;case se:var a=e,r=this.peekCodePoint(0),s=this.peekCodePoint(1);if(fe(a,r,s))return this.reconsumeCodePoint(e),this.consumeNumericToken();if(we(a,r,s))return this.reconsumeCodePoint(e),this.consumeIdentLikeToken();if(r===se&&62===s)return this.consumeCodePoint(),this.consumeCodePoint(),Le;break;case 46:if(fe(e,this.peekCodePoint(0),this.peekCodePoint(1)))return this.reconsumeCodePoint(e),this.consumeNumericToken();break;case 47:if(42===this.peekCodePoint(0))for(this.consumeCodePoint();;){var o=this.consumeCodePoint();if(42===o&&47===(o=this.consumeCodePoint()))return this.consumeToken();if(o===le)return this.consumeToken()}break;case 58:return Me;case 59:return Ne;case 60:if(33===this.peekCodePoint(0)&&this.peekCodePoint(1)===se&&this.peekCodePoint(2)===se)return this.consumeCodePoint(),this.consumeCodePoint(),Oe;break;case 64:var c=this.peekCodePoint(0),d=this.peekCodePoint(1),h=this.peekCodePoint(2);if(we(c,d,h))return{type:7,value:this.consumeName()};break;case 91:return De;case 92:if(me(e,this.peekCodePoint(0)))return this.reconsumeCodePoint(e),this.consumeIdentLikeToken();break;case 93:return Re;case 61:if(61===this.peekCodePoint(0))return this.consumeCodePoint(),ye;break;case 123:return Te;case 125:return Ie;case 117:case 85:var u=this.peekCodePoint(0),g=this.peekCodePoint(1);return u!==oe||!de(g)&&63!==g||(this.consumeCodePoint(),this.consumeUnicodeRangeToken()),this.reconsumeCodePoint(e),this.consumeIdentLikeToken();case 124:if(61===this.peekCodePoint(0))return this.consumeCodePoint(),xe;if(124===this.peekCodePoint(0))return this.consumeCodePoint(),Fe;break;case 126:if(61===this.peekCodePoint(0))return this.consumeCodePoint(),Se;break;case le:return Pe}return he(e)?(this.consumeWhiteSpace(),He):ce(e)?(this.reconsumeCodePoint(e),this.consumeNumericToken()):ue(e)?(this.reconsumeCodePoint(e),this.consumeIdentLikeToken()):{type:6,value:l(e)}},e.prototype.consumeCodePoint=function(){var e=this._value.shift();return void 0===e?-1:e},e.prototype.reconsumeCodePoint=function(e){this._value.unshift(e)},e.prototype.peekCodePoint=function(e){return e>=this._value.length?-1:this._value[e]},e.prototype.consumeUnicodeRangeToken=function(){for(var e=[],t=this.consumeCodePoint();de(t)&&e.length<6;)e.push(t),t=this.consumeCodePoint();for(var A=!1;63===t&&e.length<6;)e.push(t),t=this.consumeCodePoint(),A=!0;if(A)return{type:30,start:parseInt(l.apply(void 0,e.map((function(e){return 63===e?48:e}))),16),end:parseInt(l.apply(void 0,e.map((function(e){return 63===e?70:e}))),16)};var i=parseInt(l.apply(void 0,e),16);if(this.peekCodePoint(0)===se&&de(this.peekCodePoint(1))){this.consumeCodePoint(),t=this.consumeCodePoint();for(var n=[];de(t)&&n.length<6;)n.push(t),t=this.consumeCodePoint();return{type:30,start:i,end:parseInt(l.apply(void 0,n),16)}}return{type:30,start:i,end:i}},e.prototype.consumeIdentLikeToken=function(){var e=this.consumeName();return"url"===e.toLowerCase()&&40===this.peekCodePoint(0)?(this.consumeCodePoint(),this.consumeUrlToken()):40===this.peekCodePoint(0)?(this.consumeCodePoint(),{type:19,value:e}):{type:20,value:e}},e.prototype.consumeUrlToken=function(){var e=[];if(this.consumeWhiteSpace(),this.peekCodePoint(0)===le)return{type:22,value:""};var t=this.peekCodePoint(0);if(39===t||34===t){var A=this.consumeStringToken(this.consumeCodePoint());return 0===A.type&&(this.consumeWhiteSpace(),this.peekCodePoint(0)===le||41===this.peekCodePoint(0))?(this.consumeCodePoint(),{type:22,value:A.value}):(this.consumeBadUrlRemnants(),Ue)}for(;;){var i=this.consumeCodePoint();if(i===le||41===i)return{type:22,value:l.apply(void 0,e)};if(he(i))return this.consumeWhiteSpace(),this.peekCodePoint(0)===le||41===this.peekCodePoint(0)?(this.consumeCodePoint(),{type:22,value:l.apply(void 0,e)}):(this.consumeBadUrlRemnants(),Ue);if(34===i||39===i||40===i||pe(i))return this.consumeBadUrlRemnants(),Ue;if(92===i){if(!me(i,this.peekCodePoint(0)))return this.consumeBadUrlRemnants(),Ue;e.push(this.consumeEscapedCodePoint())}else e.push(i)}},e.prototype.consumeWhiteSpace=function(){for(;he(this.peekCodePoint(0));)this.consumeCodePoint()},e.prototype.consumeBadUrlRemnants=function(){for(;;){var e=this.consumeCodePoint();if(41===e||e===le)return;me(e,this.peekCodePoint(0))&&this.consumeEscapedCodePoint()}},e.prototype.consumeStringSlice=function(e){for(var t="";e>0;){var A=Math.min(5e4,e);t+=l.apply(void 0,this._value.splice(0,A)),e-=A}return this._value.shift(),t},e.prototype.consumeStringToken=function(e){for(var t="",A=0;;){var i=this._value[A];if(i===le||void 0===i||i===e)return{type:0,value:t+=this.consumeStringSlice(A)};if(10===i)return this._value.splice(0,A),Qe;if(92===i){var n=this._value[A+1];n!==le&&void 0!==n&&(10===n?(t+=this.consumeStringSlice(A),A=-1,this._value.shift()):me(i,n)&&(t+=this.consumeStringSlice(A),t+=l(this.consumeEscapedCodePoint()),A=-1))}A++}},e.prototype.consumeNumber=function(){var e=[],t=4,A=this.peekCodePoint(0);for(A!==oe&&A!==se||e.push(this.consumeCodePoint());ce(this.peekCodePoint(0));)e.push(this.consumeCodePoint());A=this.peekCodePoint(0);var i=this.peekCodePoint(1);if(46===A&&ce(i))for(e.push(this.consumeCodePoint(),this.consumeCodePoint()),t=8;ce(this.peekCodePoint(0));)e.push(this.consumeCodePoint());A=this.peekCodePoint(0),i=this.peekCodePoint(1);var n=this.peekCodePoint(2);if((69===A||101===A)&&((i===oe||i===se)&&ce(n)||ce(i)))for(e.push(this.consumeCodePoint(),this.consumeCodePoint()),t=8;ce(this.peekCodePoint(0));)e.push(this.consumeCodePoint());return[Ee(e),t]},e.prototype.consumeNumericToken=function(){var e=this.consumeNumber(),t=e[0],A=e[1],i=this.peekCodePoint(0),n=this.peekCodePoint(1),a=this.peekCodePoint(2);return we(i,n,a)?{type:15,number:t,flags:A,unit:this.consumeName()}:37===i?(this.consumeCodePoint(),{type:16,number:t,flags:A}):{type:17,number:t,flags:A}},e.prototype.consumeEscapedCodePoint=function(){var e=this.consumeCodePoint();if(de(e)){for(var t=l(e);de(this.peekCodePoint(0))&&t.length<6;)t+=l(this.consumeCodePoint());he(this.peekCodePoint(0))&&this.consumeCodePoint();var A=parseInt(t,16);return 0===A||function(e){return e>=55296&&e<=57343}(A)||A>1114111?65533:A}return e===le?65533:e},e.prototype.consumeName=function(){for(var e="";;){var t=this.consumeCodePoint();if(ge(t))e+=l(t);else{if(!me(t,this.peekCodePoint(0)))return this.reconsumeCodePoint(t),e;e+=l(this.consumeEscapedCodePoint())}}},e}(),Ke=function(){function e(e){this._tokens=e}return e.create=function(t){var A=new Ve;return A.write(t),new e(A.read())},e.parseValue=function(t){return e.create(t).parseComponentValue()},e.parseValues=function(t){return e.create(t).parseComponentValues()},e.prototype.parseComponentValue=function(){for(var e=this.consumeToken();31===e.type;)e=this.consumeToken();if(32===e.type)throw new SyntaxError("Error parsing CSS component value, unexpected EOF");this.reconsumeToken(e);var t=this.consumeComponentValue();do{e=this.consumeToken()}while(31===e.type);if(32===e.type)return t;throw new SyntaxError("Error parsing CSS component value, multiple values found when expecting only one")},e.prototype.parseComponentValues=function(){for(var e=[];;){var t=this.consumeComponentValue();if(32===t.type)return e;e.push(t),e.push()}},e.prototype.consumeComponentValue=function(){var e=this.consumeToken();switch(e.type){case 11:case 28:case 2:return this.consumeSimpleBlock(e.type);case 19:return this.consumeFunction(e)}return e},e.prototype.consumeSimpleBlock=function(e){for(var t={type:e,values:[]},A=this.consumeToken();;){if(32===A.type||Ze(A,e))return t;this.reconsumeToken(A),t.values.push(this.consumeComponentValue()),A=this.consumeToken()}},e.prototype.consumeFunction=function(e){for(var t={name:e.value,values:[],type:18};;){var A=this.consumeToken();if(32===A.type||3===A.type)return t;this.reconsumeToken(A),t.values.push(this.consumeComponentValue())}},e.prototype.consumeToken=function(){var e=this._tokens.shift();return void 0===e?Pe:e},e.prototype.reconsumeToken=function(e){this._tokens.unshift(e)},e}(),Ge=function(e){return 15===e.type},We=function(e){return 17===e.type},ze=function(e){return 20===e.type},Xe=function(e){return 0===e.type},Ye=function(e,t){return ze(e)&&e.value===t},je=function(e){return 31!==e.type},_e=function(e){return 31!==e.type&&4!==e.type},Je=function(e){var t=[],A=[];return e.forEach((function(e){if(4===e.type){if(0===A.length)throw new Error("Error parsing function args, zero tokens for arg");return t.push(A),void(A=[])}31!==e.type&&A.push(e)})),A.length&&t.push(A),t},Ze=function(e,t){return 11===t&&12===e.type||28===t&&29===e.type||2===t&&3===e.type},qe=function(e){return 17===e.type||15===e.type},$e=function(e){return 16===e.type||qe(e)},et=function(e){return e.length>1?[e[0],e[1]]:[e[0]]},tt={type:17,number:0,flags:4},At={type:16,number:50,flags:4},it={type:16,number:100,flags:4},nt=function(e,t,A){var i=e[0],n=e[1];return[at(i,t),at(void 0!==n?n:i,A)]},at=function(e,t){if(16===e.type)return e.number/100*t;if(Ge(e))switch(e.unit){case"rem":case"em":return 16*e.number;default:return e.number}return e.number},rt="grad",st="turn",ot=function(e,t){if(15===t.type)switch(t.unit){case"deg":return Math.PI*t.number/180;case rt:return Math.PI/200*t.number;case"rad":return t.number;case st:return 2*Math.PI*t.number}throw new Error("Unsupported angle type")},lt=function(e){return 15===e.type&&("deg"===e.unit||e.unit===rt||"rad"===e.unit||e.unit===st)},ct=function(e){switch(e.filter(ze).map((function(e){return e.value})).join(" ")){case"to bottom right":case"to right bottom":case"left top":case"top left":return[tt,tt];case"to top":case"bottom":return dt(0);case"to bottom left":case"to left bottom":case"right top":case"top right":return[tt,it];case"to right":case"left":return dt(90);case"to top left":case"to left top":case"right bottom":case"bottom right":return[it,it];case"to bottom":case"top":return dt(180);case"to top right":case"to right top":case"left bottom":case"bottom left":return[it,tt];case"to left":case"right":return dt(270)}return 0},dt=function(e){return Math.PI*e/180},ht=function(e,t){if(18===t.type){var A=Bt[t.name];if(void 0===A)throw new Error('Attempting to parse an unsupported color function "'+t.name+'"');return A(e,t.values)}if(5===t.type){if(3===t.value.length){var i=t.value.substring(0,1),n=t.value.substring(1,2),a=t.value.substring(2,3);return pt(parseInt(i+i,16),parseInt(n+n,16),parseInt(a+a,16),1)}if(4===t.value.length){i=t.value.substring(0,1),n=t.value.substring(1,2),a=t.value.substring(2,3);var r=t.value.substring(3,4);return pt(parseInt(i+i,16),parseInt(n+n,16),parseInt(a+a,16),parseInt(r+r,16)/255)}if(6===t.value.length)return i=t.value.substring(0,2),n=t.value.substring(2,4),a=t.value.substring(4,6),pt(parseInt(i,16),parseInt(n,16),parseInt(a,16),1);if(8===t.value.length)return i=t.value.substring(0,2),n=t.value.substring(2,4),a=t.value.substring(4,6),r=t.value.substring(6,8),pt(parseInt(i,16),parseInt(n,16),parseInt(a,16),parseInt(r,16)/255)}if(20===t.type){var s=vt[t.value.toUpperCase()];if(void 0!==s)return s}return vt.TRANSPARENT},ut=function(e){return 0==(255&e)},gt=function(e){var t=255&e,A=255&e>>8,i=255&e>>16,n=255&e>>24;return t<255?"rgba("+n+","+i+","+A+","+t/255+")":"rgb("+n+","+i+","+A+")"},pt=function(e,t,A,i){return(e<<24|t<<16|A<<8|Math.round(255*i)<<0)>>>0},mt=function(e,t){if(17===e.type)return e.number;if(16===e.type){var A=3===t?1:255;return 3===t?e.number/100*A:Math.round(e.number/100*A)}return 0},wt=function(e,t){var A=t.filter(_e);if(3===A.length){var i=A.map(mt),n=i[0],a=i[1],r=i[2];return pt(n,a,r,1)}if(4===A.length){var s=A.map(mt),o=(n=s[0],a=s[1],r=s[2],s[3]);return pt(n,a,r,o)}return 0};function ft(e,t,A){return A<0&&(A+=1),A>=1&&(A-=1),A<1/6?(t-e)*A*6+e:A<.5?t:A<2/3?6*(t-e)*(2/3-A)+e:e}var Et=function(e,t){var A=t.filter(_e),i=A[0],n=A[1],a=A[2],r=A[3],s=(17===i.type?dt(i.number):ot(e,i))/(2*Math.PI),o=$e(n)?n.number/100:0,l=$e(a)?a.number/100:0,c=void 0!==r&&$e(r)?at(r,1):1;if(0===o)return pt(255*l,255*l,255*l,1);var d=l<=.5?l*(o+1):l+o-l*o,h=2*l-d,u=ft(h,d,s+1/3),g=ft(h,d,s),p=ft(h,d,s-1/3);return pt(255*u,255*g,255*p,c)},Bt={hsl:Et,hsla:Et,rgb:wt,rgba:wt},bt=function(e,t){return ht(e,Ke.create(t).parseComponentValue())},vt={ALICEBLUE:4042850303,ANTIQUEWHITE:4209760255,AQUA:16777215,AQUAMARINE:2147472639,AZURE:4043309055,BEIGE:4126530815,BISQUE:4293182719,BLACK:255,BLANCHEDALMOND:4293643775,BLUE:65535,BLUEVIOLET:2318131967,BROWN:2771004159,BURLYWOOD:3736635391,CADETBLUE:1604231423,CHARTREUSE:2147418367,CHOCOLATE:3530104575,CORAL:4286533887,CORNFLOWERBLUE:1687547391,CORNSILK:4294499583,CRIMSON:3692313855,CYAN:16777215,DARKBLUE:35839,DARKCYAN:9145343,DARKGOLDENROD:3095837695,DARKGRAY:2846468607,DARKGREEN:6553855,DARKGREY:2846468607,DARKKHAKI:3182914559,DARKMAGENTA:2332068863,DARKOLIVEGREEN:1433087999,DARKORANGE:4287365375,DARKORCHID:2570243327,DARKRED:2332033279,DARKSALMON:3918953215,DARKSEAGREEN:2411499519,DARKSLATEBLUE:1211993087,DARKSLATEGRAY:793726975,DARKSLATEGREY:793726975,DARKTURQUOISE:13554175,DARKVIOLET:2483082239,DEEPPINK:4279538687,DEEPSKYBLUE:12582911,DIMGRAY:1768516095,DIMGREY:1768516095,DODGERBLUE:512819199,FIREBRICK:2988581631,FLORALWHITE:4294635775,FORESTGREEN:579543807,FUCHSIA:4278255615,GAINSBORO:3705462015,GHOSTWHITE:4177068031,GOLD:4292280575,GOLDENROD:3668254975,GRAY:2155905279,GREEN:8388863,GREENYELLOW:2919182335,GREY:2155905279,HONEYDEW:4043305215,HOTPINK:4285117695,INDIANRED:3445382399,INDIGO:1258324735,IVORY:4294963455,KHAKI:4041641215,LAVENDER:3873897215,LAVENDERBLUSH:4293981695,LAWNGREEN:2096890111,LEMONCHIFFON:4294626815,LIGHTBLUE:2916673279,LIGHTCORAL:4034953471,LIGHTCYAN:3774873599,LIGHTGOLDENRODYELLOW:4210742015,LIGHTGRAY:3553874943,LIGHTGREEN:2431553791,LIGHTGREY:3553874943,LIGHTPINK:4290167295,LIGHTSALMON:4288707327,LIGHTSEAGREEN:548580095,LIGHTSKYBLUE:2278488831,LIGHTSLATEGRAY:2005441023,LIGHTSLATEGREY:2005441023,LIGHTSTEELBLUE:2965692159,LIGHTYELLOW:4294959359,LIME:16711935,LIMEGREEN:852308735,LINEN:4210091775,MAGENTA:4278255615,MAROON:2147483903,MEDIUMAQUAMARINE:1724754687,MEDIUMBLUE:52735,MEDIUMORCHID:3126187007,MEDIUMPURPLE:2473647103,MEDIUMSEAGREEN:1018393087,MEDIUMSLATEBLUE:2070474495,MEDIUMSPRINGGREEN:16423679,MEDIUMTURQUOISE:1221709055,MEDIUMVIOLETRED:3340076543,MIDNIGHTBLUE:421097727,MINTCREAM:4127193855,MISTYROSE:4293190143,MOCCASIN:4293178879,NAVAJOWHITE:4292783615,NAVY:33023,OLDLACE:4260751103,OLIVE:2155872511,OLIVEDRAB:1804477439,ORANGE:4289003775,ORANGERED:4282712319,ORCHID:3664828159,PALEGOLDENROD:4008225535,PALEGREEN:2566625535,PALETURQUOISE:2951671551,PALEVIOLETRED:3681588223,PAPAYAWHIP:4293907967,PEACHPUFF:4292524543,PERU:3448061951,PINK:4290825215,PLUM:3718307327,POWDERBLUE:2967529215,PURPLE:2147516671,REBECCAPURPLE:1714657791,RED:4278190335,ROSYBROWN:3163525119,ROYALBLUE:1097458175,SADDLEBROWN:2336560127,SALMON:4202722047,SANDYBROWN:4104413439,SEAGREEN:780883967,SEASHELL:4294307583,SIENNA:2689740287,SILVER:3233857791,SKYBLUE:2278484991,SLATEBLUE:1784335871,SLATEGRAY:1887473919,SLATEGREY:1887473919,SNOW:4294638335,SPRINGGREEN:16744447,STEELBLUE:1182971135,TAN:3535047935,TEAL:8421631,THISTLE:3636451583,TOMATO:4284696575,TRANSPARENT:0,TURQUOISE:1088475391,VIOLET:4001558271,WHEAT:4125012991,WHITE:4294967295,WHITESMOKE:4126537215,YELLOW:4294902015,YELLOWGREEN:2597139199},Ct={name:"background-clip",initialValue:"border-box",prefix:!1,type:1,parse:function(e,t){return t.map((function(e){if(ze(e))switch(e.value){case"padding-box":return 1;case"content-box":return 2}return 0}))}},yt={name:"background-color",initialValue:"transparent",prefix:!1,type:3,format:"color"},Ft=function(e,t){var A=ht(e,t[0]),i=t[1];return i&&$e(i)?{color:A,stop:i}:{color:A,stop:null}},xt=function(e,t){var A=e[0],i=e[e.length-1];null===A.stop&&(A.stop=tt),null===i.stop&&(i.stop=it);for(var n=[],a=0,r=0;ra?n.push(o):n.push(a),a=o}else n.push(null)}var l=null;for(r=0;re.optimumDistance)?{optimumCorner:t,optimumDistance:s}:e}),{optimumDistance:n?1/0:-1/0,optimumCorner:null}).optimumCorner},kt=function(e,t){var A=dt(180),i=[];return Je(t).forEach((function(t,n){if(0===n){var a=t[0];if(20===a.type&&-1!==["top","left","right","bottom"].indexOf(a.value))return void(A=ct(t));if(lt(a))return void(A=(ot(e,a)+dt(270))%dt(360))}var r=Ft(e,t);i.push(r)})),{angle:A,stops:i,type:1}},Ut="closest-side",Qt="farthest-side",Ot="closest-corner",Lt="farthest-corner",Mt="circle",Nt="ellipse",Dt="cover",Rt="contain",Ht=function(e,t){var A=0,i=3,n=[],a=[];return Je(t).forEach((function(t,r){var s=!0;if(0===r?s=t.reduce((function(e,t){if(ze(t))switch(t.value){case"center":return a.push(At),!1;case"top":case"left":return a.push(tt),!1;case"right":case"bottom":return a.push(it),!1}else if($e(t)||qe(t))return a.push(t),!1;return e}),s):1===r&&(s=t.reduce((function(e,t){if(ze(t))switch(t.value){case Mt:return A=0,!1;case Nt:return A=1,!1;case Rt:case Ut:return i=0,!1;case Qt:return i=1,!1;case Ot:return i=2,!1;case Dt:case Lt:return i=3,!1}else if(qe(t)||$e(t))return Array.isArray(i)||(i=[]),i.push(t),!1;return e}),s)),s){var o=Ft(e,t);n.push(o)}})),{size:i,shape:A,stops:n,position:a,type:2}},Pt=function(e,t){if(22===t.type){var A={url:t.value,type:0};return e.cache.addImage(t.value),A}if(18===t.type){var i=Kt[t.name];if(void 0===i)throw new Error('Attempting to parse an unsupported image function "'+t.name+'"');return i(e,t.values)}throw new Error("Unsupported image type "+t.type)};var Vt,Kt={"linear-gradient":function(e,t){var A=dt(180),i=[];return Je(t).forEach((function(t,n){if(0===n){var a=t[0];if(20===a.type&&"to"===a.value)return void(A=ct(t));if(lt(a))return void(A=ot(e,a))}var r=Ft(e,t);i.push(r)})),{angle:A,stops:i,type:1}},"-moz-linear-gradient":kt,"-ms-linear-gradient":kt,"-o-linear-gradient":kt,"-webkit-linear-gradient":kt,"radial-gradient":function(e,t){var A=0,i=3,n=[],a=[];return Je(t).forEach((function(t,r){var s=!0;if(0===r){var o=!1;s=t.reduce((function(e,t){if(o)if(ze(t))switch(t.value){case"center":return a.push(At),e;case"top":case"left":return a.push(tt),e;case"right":case"bottom":return a.push(it),e}else($e(t)||qe(t))&&a.push(t);else if(ze(t))switch(t.value){case Mt:return A=0,!1;case Nt:return A=1,!1;case"at":return o=!0,!1;case Ut:return i=0,!1;case Dt:case Qt:return i=1,!1;case Rt:case Ot:return i=2,!1;case Lt:return i=3,!1}else if(qe(t)||$e(t))return Array.isArray(i)||(i=[]),i.push(t),!1;return e}),s)}if(s){var l=Ft(e,t);n.push(l)}})),{size:i,shape:A,stops:n,position:a,type:2}},"-moz-radial-gradient":Ht,"-ms-radial-gradient":Ht,"-o-radial-gradient":Ht,"-webkit-radial-gradient":Ht,"-webkit-gradient":function(e,t){var A=dt(180),i=[],n=1;return Je(t).forEach((function(t,A){var a=t[0];if(0===A){if(ze(a)&&"linear"===a.value)return void(n=1);if(ze(a)&&"radial"===a.value)return void(n=2)}if(18===a.type)if("from"===a.name){var r=ht(e,a.values[0]);i.push({stop:tt,color:r})}else if("to"===a.name)r=ht(e,a.values[0]),i.push({stop:it,color:r});else if("color-stop"===a.name){var s=a.values.filter(_e);if(2===s.length){r=ht(e,s[1]);var o=s[0];We(o)&&i.push({stop:{type:16,number:100*o.number,flags:o.flags},color:r})}}})),1===n?{angle:(A+dt(180))%dt(360),stops:i,type:n}:{size:3,shape:0,stops:i,position:[],type:n}}},Gt={name:"background-image",initialValue:"none",type:1,prefix:!1,parse:function(e,t){if(0===t.length)return[];var A=t[0];return 20===A.type&&"none"===A.value?[]:t.filter((function(e){return _e(e)&&function(e){return!(20===e.type&&"none"===e.value||18===e.type&&!Kt[e.name])}(e)})).map((function(t){return Pt(e,t)}))}},Wt={name:"background-origin",initialValue:"border-box",prefix:!1,type:1,parse:function(e,t){return t.map((function(e){if(ze(e))switch(e.value){case"padding-box":return 1;case"content-box":return 2}return 0}))}},zt={name:"background-position",initialValue:"0% 0%",type:1,prefix:!1,parse:function(e,t){return Je(t).map((function(e){return e.filter($e)})).map(et)}},Xt={name:"background-repeat",initialValue:"repeat",prefix:!1,type:1,parse:function(e,t){return Je(t).map((function(e){return e.filter(ze).map((function(e){return e.value})).join(" ")})).map(Yt)}},Yt=function(e){switch(e){case"no-repeat":return 1;case"repeat-x":case"repeat no-repeat":return 2;case"repeat-y":case"no-repeat repeat":return 3;default:return 0}};!function(e){e.AUTO="auto",e.CONTAIN="contain",e.COVER="cover"}(Vt||(Vt={}));var jt,_t={name:"background-size",initialValue:"0",prefix:!1,type:1,parse:function(e,t){return Je(t).map((function(e){return e.filter(Jt)}))}},Jt=function(e){return ze(e)||$e(e)},Zt=function(e){return{name:"border-"+e+"-color",initialValue:"transparent",prefix:!1,type:3,format:"color"}},qt=Zt("top"),$t=Zt("right"),eA=Zt("bottom"),tA=Zt("left"),AA=function(e){return{name:"border-radius-"+e,initialValue:"0 0",prefix:!1,type:1,parse:function(e,t){return et(t.filter($e))}}},iA=AA("top-left"),nA=AA("top-right"),aA=AA("bottom-right"),rA=AA("bottom-left"),sA=function(e){return{name:"border-"+e+"-style",initialValue:"solid",prefix:!1,type:2,parse:function(e,t){switch(t){case"none":return 0;case"dashed":return 2;case"dotted":return 3;case"double":return 4}return 1}}},oA=sA("top"),lA=sA("right"),cA=sA("bottom"),dA=sA("left"),hA=function(e){return{name:"border-"+e+"-width",initialValue:"0",type:0,prefix:!1,parse:function(e,t){return Ge(t)?t.number:0}}},uA=hA("top"),gA=hA("right"),pA=hA("bottom"),mA=hA("left"),wA={name:"color",initialValue:"transparent",prefix:!1,type:3,format:"color"},fA={name:"direction",initialValue:"ltr",prefix:!1,type:2,parse:function(e,t){return"rtl"===t?1:0}},EA={name:"display",initialValue:"inline-block",prefix:!1,type:1,parse:function(e,t){return t.filter(ze).reduce((function(e,t){return e|BA(t.value)}),0)}},BA=function(e){switch(e){case"block":case"-webkit-box":return 2;case"inline":return 4;case"run-in":return 8;case"flow":return 16;case"flow-root":return 32;case"table":return 64;case"flex":case"-webkit-flex":return 128;case"grid":case"-ms-grid":return 256;case"ruby":return 512;case"subgrid":return 1024;case"list-item":return 2048;case"table-row-group":return 4096;case"table-header-group":return 8192;case"table-footer-group":return 16384;case"table-row":return 32768;case"table-cell":return 65536;case"table-column-group":return 131072;case"table-column":return 262144;case"table-caption":return 524288;case"ruby-base":return 1048576;case"ruby-text":return 2097152;case"ruby-base-container":return 4194304;case"ruby-text-container":return 8388608;case"contents":return 16777216;case"inline-block":return 33554432;case"inline-list-item":return 67108864;case"inline-table":return 134217728;case"inline-flex":return 268435456;case"inline-grid":return 536870912}return 0},bA={name:"float",initialValue:"none",prefix:!1,type:2,parse:function(e,t){switch(t){case"left":return 1;case"right":return 2;case"inline-start":return 3;case"inline-end":return 4}return 0}},vA={name:"letter-spacing",initialValue:"0",prefix:!1,type:0,parse:function(e,t){return 20===t.type&&"normal"===t.value?0:17===t.type||15===t.type?t.number:0}};!function(e){e.NORMAL="normal",e.STRICT="strict"}(jt||(jt={}));var CA,yA={name:"line-break",initialValue:"normal",prefix:!1,type:2,parse:function(e,t){return"strict"===t?jt.STRICT:jt.NORMAL}},FA={name:"line-height",initialValue:"normal",prefix:!1,type:4},xA=function(e,t){return ze(e)&&"normal"===e.value?1.2*t:17===e.type?t*e.number:$e(e)?at(e,t):t},SA={name:"list-style-image",initialValue:"none",type:0,prefix:!1,parse:function(e,t){return 20===t.type&&"none"===t.value?null:Pt(e,t)}},TA={name:"list-style-position",initialValue:"outside",prefix:!1,type:2,parse:function(e,t){return"inside"===t?0:1}},IA={name:"list-style-type",initialValue:"none",prefix:!1,type:2,parse:function(e,t){switch(t){case"disc":return 0;case"circle":return 1;case"square":return 2;case"decimal":return 3;case"cjk-decimal":return 4;case"decimal-leading-zero":return 5;case"lower-roman":return 6;case"upper-roman":return 7;case"lower-greek":return 8;case"lower-alpha":return 9;case"upper-alpha":return 10;case"arabic-indic":return 11;case"armenian":return 12;case"bengali":return 13;case"cambodian":return 14;case"cjk-earthly-branch":return 15;case"cjk-heavenly-stem":return 16;case"cjk-ideographic":return 17;case"devanagari":return 18;case"ethiopic-numeric":return 19;case"georgian":return 20;case"gujarati":return 21;case"gurmukhi":case"hebrew":return 22;case"hiragana":return 23;case"hiragana-iroha":return 24;case"japanese-formal":return 25;case"japanese-informal":return 26;case"kannada":return 27;case"katakana":return 28;case"katakana-iroha":return 29;case"khmer":return 30;case"korean-hangul-formal":return 31;case"korean-hanja-formal":return 32;case"korean-hanja-informal":return 33;case"lao":return 34;case"lower-armenian":return 35;case"malayalam":return 36;case"mongolian":return 37;case"myanmar":return 38;case"oriya":return 39;case"persian":return 40;case"simp-chinese-formal":return 41;case"simp-chinese-informal":return 42;case"tamil":return 43;case"telugu":return 44;case"thai":return 45;case"tibetan":return 46;case"trad-chinese-formal":return 47;case"trad-chinese-informal":return 48;case"upper-armenian":return 49;case"disclosure-open":return 50;case"disclosure-closed":return 51;default:return-1}}},kA=function(e){return{name:"margin-"+e,initialValue:"0",prefix:!1,type:4}},UA=kA("top"),QA=kA("right"),OA=kA("bottom"),LA=kA("left"),MA={name:"overflow",initialValue:"visible",prefix:!1,type:1,parse:function(e,t){return t.filter(ze).map((function(e){switch(e.value){case"hidden":return 1;case"scroll":return 2;case"clip":return 3;case"auto":return 4;default:return 0}}))}},NA={name:"overflow-wrap",initialValue:"normal",prefix:!1,type:2,parse:function(e,t){return"break-word"===t?"break-word":"normal"}},DA=function(e){return{name:"padding-"+e,initialValue:"0",prefix:!1,type:3,format:"length-percentage"}},RA=DA("top"),HA=DA("right"),PA=DA("bottom"),VA=DA("left"),KA={name:"text-align",initialValue:"left",prefix:!1,type:2,parse:function(e,t){switch(t){case"right":return 2;case"center":case"justify":return 1;default:return 0}}},GA={name:"position",initialValue:"static",prefix:!1,type:2,parse:function(e,t){switch(t){case"relative":return 1;case"absolute":return 2;case"fixed":return 3;case"sticky":return 4}return 0}},WA={name:"text-shadow",initialValue:"none",type:1,prefix:!1,parse:function(e,t){return 1===t.length&&Ye(t[0],"none")?[]:Je(t).map((function(t){for(var A={color:vt.TRANSPARENT,offsetX:tt,offsetY:tt,blur:tt},i=0,n=0;n1?1:0],this.overflowWrap=Ci(e,NA,t.overflowWrap),this.paddingTop=Ci(e,RA,t.paddingTop),this.paddingRight=Ci(e,HA,t.paddingRight),this.paddingBottom=Ci(e,PA,t.paddingBottom),this.paddingLeft=Ci(e,VA,t.paddingLeft),this.paintOrder=Ci(e,wi,t.paintOrder),this.position=Ci(e,GA,t.position),this.textAlign=Ci(e,KA,t.textAlign),this.textDecorationColor=Ci(e,Ai,null!==(A=t.textDecorationColor)&&void 0!==A?A:t.color),this.textDecorationLine=Ci(e,ii,null!==(i=t.textDecorationLine)&&void 0!==i?i:t.textDecoration),this.textShadow=Ci(e,WA,t.textShadow),this.textTransform=Ci(e,zA,t.textTransform),this.transform=Ci(e,XA,t.transform),this.transformOrigin=Ci(e,JA,t.transformOrigin),this.visibility=Ci(e,ZA,t.visibility),this.webkitTextStrokeColor=Ci(e,fi,t.webkitTextStrokeColor),this.webkitTextStrokeWidth=Ci(e,Ei,t.webkitTextStrokeWidth),this.wordBreak=Ci(e,qA,t.wordBreak),this.zIndex=Ci(e,$A,t.zIndex)}return e.prototype.isVisible=function(){return this.display>0&&this.opacity>0&&0===this.visibility},e.prototype.isTransparent=function(){return ut(this.backgroundColor)},e.prototype.isTransformed=function(){return null!==this.transform},e.prototype.isPositioned=function(){return 0!==this.position},e.prototype.isPositionedWithZIndex=function(){return this.isPositioned()&&!this.zIndex.auto},e.prototype.isFloating=function(){return 0!==this.float},e.prototype.isInlineLevel=function(){return li(this.display,4)||li(this.display,33554432)||li(this.display,268435456)||li(this.display,536870912)||li(this.display,67108864)||li(this.display,134217728)},e}(),bi=function(e,t){this.content=Ci(e,ci,t.content),this.quotes=Ci(e,gi,t.quotes)},vi=function(e,t){this.counterIncrement=Ci(e,di,t.counterIncrement),this.counterReset=Ci(e,hi,t.counterReset)},Ci=function(e,t,A){var i=new Ve,n=null!=A?A.toString():t.initialValue;i.write(n);var a=new Ke(i.read());switch(t.type){case 2:var r=a.parseComponentValue();return t.parse(e,ze(r)?r.value:t.initialValue);case 0:return t.parse(e,a.parseComponentValue());case 1:return t.parse(e,a.parseComponentValues());case 4:return a.parseComponentValue();case 3:switch(t.format){case"angle":return ot(e,a.parseComponentValue());case"color":return ht(e,a.parseComponentValue());case"image":return Pt(e,a.parseComponentValue());case"length":var s=a.parseComponentValue();return qe(s)?s:tt;case"length-percentage":var o=a.parseComponentValue();return $e(o)?o:tt;case"time":return ei.parse(e,a.parseComponentValue())}}},yi=function(e,t){var A=function(e){switch(e.getAttribute("data-html2canvas-debug")){case"all":return 1;case"clone":return 2;case"parse":return 3;case"render":return 4;default:return 0}}(e);return 1===A||t===A},Fi=function(e,t){this.context=e,this.textNodes=[],this.elements=[],this.flags=0,yi(t,3),this.styles=new Bi(e,window.getComputedStyle(t,null)),kn(t)&&(this.styles.animationDuration.some((function(e){return e>0}))&&(t.style.animationDuration="0s"),null!==this.styles.transform&&(t.style.transform="none")),this.bounds=s(this.context,t),yi(t,4)&&(this.flags|=16)},xi="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",Si="undefined"==typeof Uint8Array?[]:new Uint8Array(256),Ti=0;Ti=0){if(e<55296||e>56319&&e<=65535)return t=((t=this.index[e>>5])<<2)+(31&e),this.data[t];if(e<=65535)return t=((t=this.index[2048+(e-55296>>5)])<<2)+(31&e),this.data[t];if(e>11),t=this.index[t],t+=e>>5&63,t=((t=this.index[t])<<2)+(31&e),this.data[t];if(e<=1114111)return this.data[this.highValueIndex]}return this.errorValue},e}(),Ui="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",Qi="undefined"==typeof Uint8Array?[]:new Uint8Array(256),Oi=0;Oi>10),r%1024+56320)),(n+1===A||i.length>16384)&&(a+=String.fromCharCode.apply(String,i),i.length=0)}return a},Pi=function(e,t){var A=function(e){var t,A,i,n,a,r=.75*e.length,s=e.length,o=0;"="===e[e.length-1]&&(r--,"="===e[e.length-2]&&r--);var l="undefined"!=typeof ArrayBuffer&&"undefined"!=typeof Uint8Array&&void 0!==Uint8Array.prototype.slice?new ArrayBuffer(r):new Array(r),c=Array.isArray(l)?l:new Uint8Array(l);for(t=0;t>4,c[o++]=(15&i)<<4|n>>2,c[o++]=(3&n)<<6|63&a;return l}(e),i=Array.isArray(A)?function(e){for(var t=e.length,A=[],i=0;i=55296&&n<=56319&&A=A)return{done:!0,value:null};for(var e=Vi;ir.x||n.y>r.y;return r=n,0===t||s}));return e.body.removeChild(t),s}(document);return Object.defineProperty(ji,"SUPPORT_WORD_BREAKING",{value:e}),e},get SUPPORT_SVG_DRAWING(){var e=function(e){var t=new Image,A=e.createElement("canvas"),i=A.getContext("2d");if(!i)return!1;t.src="data:image/svg+xml,";try{i.drawImage(t,0,0),A.toDataURL()}catch(e){return!1}return!0}(document);return Object.defineProperty(ji,"SUPPORT_SVG_DRAWING",{value:e}),e},get SUPPORT_FOREIGNOBJECT_DRAWING(){var e="function"==typeof Array.from&&"function"==typeof window.fetch?function(e){var t=e.createElement("canvas"),A=100;t.width=A,t.height=A;var i=t.getContext("2d");if(!i)return Promise.reject(!1);i.fillStyle="rgb(0, 255, 0)",i.fillRect(0,0,A,A);var n=new Image,a=t.toDataURL();n.src=a;var r=Xi(A,A,0,0,n);return i.fillStyle="red",i.fillRect(0,0,A,A),Yi(r).then((function(t){i.drawImage(t,0,0);var n=i.getImageData(0,0,A,A).data;i.fillStyle="red",i.fillRect(0,0,A,A);var r=e.createElement("div");return r.style.backgroundImage="url("+a+")",r.style.height="100px",zi(n)?Yi(Xi(A,A,0,0,r)):Promise.reject(!1)})).then((function(e){return i.drawImage(e,0,0),zi(i.getImageData(0,0,A,A).data)})).catch((function(){return!1}))}(document):Promise.resolve(!1);return Object.defineProperty(ji,"SUPPORT_FOREIGNOBJECT_DRAWING",{value:e}),e},get SUPPORT_CORS_IMAGES(){var e=void 0!==(new Image).crossOrigin;return Object.defineProperty(ji,"SUPPORT_CORS_IMAGES",{value:e}),e},get SUPPORT_RESPONSE_TYPE(){var e="string"==typeof(new XMLHttpRequest).responseType;return Object.defineProperty(ji,"SUPPORT_RESPONSE_TYPE",{value:e}),e},get SUPPORT_CORS_XHR(){var e="withCredentials"in new XMLHttpRequest;return Object.defineProperty(ji,"SUPPORT_CORS_XHR",{value:e}),e},get SUPPORT_NATIVE_TEXT_SEGMENTATION(){var e=!("undefined"==typeof Intl||!Intl.Segmenter);return Object.defineProperty(ji,"SUPPORT_NATIVE_TEXT_SEGMENTATION",{value:e}),e}},_i=function(e,t){this.text=e,this.bounds=t},Ji=function(e,t){var A=t.ownerDocument;if(A){var i=A.createElement("html2canvaswrapper");i.appendChild(t.cloneNode(!0));var n=t.parentNode;if(n){n.replaceChild(i,t);var a=s(e,i);return i.firstChild&&n.replaceChild(i.firstChild,i),a}}return r.EMPTY},Zi=function(e,t,A){var i=e.ownerDocument;if(!i)throw new Error("Node has no owner document");var n=i.createRange();return n.setStart(e,t),n.setEnd(e,t+A),n},qi=function(e){if(ji.SUPPORT_NATIVE_TEXT_SEGMENTATION){var t=new Intl.Segmenter(void 0,{granularity:"grapheme"});return Array.from(t.segment(e)).map((function(e){return e.segment}))}return function(e){for(var t,A=Wi(e),i=[];!(t=A.next()).done;)t.value&&i.push(t.value.slice());return i}(e)},$i=function(e,t){return 0!==t.letterSpacing?qi(e):function(e,t){if(ji.SUPPORT_NATIVE_TEXT_SEGMENTATION){var A=new Intl.Segmenter(void 0,{granularity:"word"});return Array.from(A.segment(e)).map((function(e){return e.segment}))}return tn(e,t)}(e,t)},en=[32,160,4961,65792,65793,4153,4241],tn=function(e,t){for(var A,i=function(e,t){var A=o(e),i=ae(A,t),n=i[0],a=i[1],r=i[2],s=A.length,l=0,c=0;return{next:function(){if(c>=s)return{done:!0,value:null};for(var e=X;c0)if(ji.SUPPORT_RANGE_BOUNDS){var n=Zi(i,s,t.length).getClientRects();if(n.length>1){var o=qi(t),l=0;o.forEach((function(t){a.push(new _i(t,r.fromDOMRectList(e,Zi(i,l+s,t.length).getClientRects()))),l+=t.length}))}else a.push(new _i(t,r.fromDOMRectList(e,n)))}else{var c=i.splitText(t.length);a.push(new _i(t,Ji(e,i))),i=c}else ji.SUPPORT_RANGE_BOUNDS||(i=i.splitText(t.length));s+=t.length})),a}(e,this.text,A,t)},nn=function(e,t){switch(t){case 1:return e.toLowerCase();case 3:return e.replace(an,rn);case 2:return e.toUpperCase();default:return e}},an=/(^|\s|:|-|\(|\))([a-z])/g,rn=function(e,t,A){return e.length>0?t+A.toUpperCase():e},sn=function(e){function A(t,A){var i=e.call(this,t,A)||this;return i.src=A.currentSrc||A.src,i.intrinsicWidth=A.naturalWidth,i.intrinsicHeight=A.naturalHeight,i.context.cache.addImage(i.src),i}return t(A,e),A}(Fi),on=function(e){function A(t,A){var i=e.call(this,t,A)||this;return i.canvas=A,i.intrinsicWidth=A.width,i.intrinsicHeight=A.height,i}return t(A,e),A}(Fi),ln=function(e){function A(t,A){var i=e.call(this,t,A)||this,n=new XMLSerializer,a=s(t,A);return A.setAttribute("width",a.width+"px"),A.setAttribute("height",a.height+"px"),i.svg="data:image/svg+xml,"+encodeURIComponent(n.serializeToString(A)),i.intrinsicWidth=A.width.baseVal.value,i.intrinsicHeight=A.height.baseVal.value,i.context.cache.addImage(i.svg),i}return t(A,e),A}(Fi),cn=function(e){function A(t,A){var i=e.call(this,t,A)||this;return i.value=A.value,i}return t(A,e),A}(Fi),dn=function(e){function A(t,A){var i=e.call(this,t,A)||this;return i.start=A.start,i.reversed="boolean"==typeof A.reversed&&!0===A.reversed,i}return t(A,e),A}(Fi),hn=[{type:15,flags:0,unit:"px",number:3}],un=[{type:16,flags:0,number:50}],gn="checkbox",pn="radio",mn="password",wn=707406591,fn=function(e){function A(t,A){var i,n,a,s=e.call(this,t,A)||this;switch(s.type=A.type.toLowerCase(),s.checked=A.checked,s.value=0===(a=(n=A).type===mn?new Array(n.value.length+1).join("•"):n.value).length?n.placeholder||"":a,s.type!==gn&&s.type!==pn||(s.styles.backgroundColor=3739148031,s.styles.borderTopColor=s.styles.borderRightColor=s.styles.borderBottomColor=s.styles.borderLeftColor=2779096575,s.styles.borderTopWidth=s.styles.borderRightWidth=s.styles.borderBottomWidth=s.styles.borderLeftWidth=1,s.styles.borderTopStyle=s.styles.borderRightStyle=s.styles.borderBottomStyle=s.styles.borderLeftStyle=1,s.styles.backgroundClip=[0],s.styles.backgroundOrigin=[0],s.bounds=(i=s.bounds).width>i.height?new r(i.left+(i.width-i.height)/2,i.top,i.height,i.height):i.width0)A.textNodes.push(new An(e,n,A.styles));else if(In(n))if(Wn(n)&&n.assignedNodes)n.assignedNodes().forEach((function(t){return Cn(e,t,A,i)}));else{var r=yn(e,n);r.styles.isVisible()&&(xn(n,r,i)?r.flags|=4:Sn(r.styles)&&(r.flags|=2),-1!==vn.indexOf(n.tagName)&&(r.flags|=8),A.elements.push(r),n.slot,n.shadowRoot?Cn(e,n.shadowRoot,r,i):Kn(n)||Mn(n)||Gn(n)||Cn(e,n,r,i))}},yn=function(e,t){return Hn(t)?new sn(e,t):Dn(t)?new on(e,t):Mn(t)?new ln(e,t):Qn(t)?new cn(e,t):On(t)?new dn(e,t):Ln(t)?new fn(e,t):Gn(t)?new En(e,t):Kn(t)?new Bn(e,t):Pn(t)?new bn(e,t):new Fi(e,t)},Fn=function(e,t){var A=yn(e,t);return A.flags|=4,Cn(e,t,A,A),A},xn=function(e,t,A){return t.styles.isPositionedWithZIndex()||t.styles.opacity<1||t.styles.isTransformed()||Nn(e)&&A.styles.isTransparent()},Sn=function(e){return e.isPositioned()||e.isFloating()},Tn=function(e){return e.nodeType===Node.TEXT_NODE},In=function(e){return e.nodeType===Node.ELEMENT_NODE},kn=function(e){return In(e)&&void 0!==e.style&&!Un(e)},Un=function(e){return"object"==typeof e.className},Qn=function(e){return"LI"===e.tagName},On=function(e){return"OL"===e.tagName},Ln=function(e){return"INPUT"===e.tagName},Mn=function(e){return"svg"===e.tagName},Nn=function(e){return"BODY"===e.tagName},Dn=function(e){return"CANVAS"===e.tagName},Rn=function(e){return"VIDEO"===e.tagName},Hn=function(e){return"IMG"===e.tagName},Pn=function(e){return"IFRAME"===e.tagName},Vn=function(e){return"STYLE"===e.tagName},Kn=function(e){return"TEXTAREA"===e.tagName},Gn=function(e){return"SELECT"===e.tagName},Wn=function(e){return"SLOT"===e.tagName},zn=function(e){return e.tagName.indexOf("-")>0},Xn=function(){function e(){this.counters={}}return e.prototype.getCounterValue=function(e){var t=this.counters[e];return t&&t.length?t[t.length-1]:1},e.prototype.getCounterValues=function(e){return this.counters[e]||[]},e.prototype.pop=function(e){var t=this;e.forEach((function(e){return t.counters[e].pop()}))},e.prototype.parse=function(e){var t=this,A=e.counterIncrement,i=e.counterReset,n=!0;null!==A&&A.forEach((function(e){var A=t.counters[e.counter];A&&0!==e.increment&&(n=!1,A.length||A.push(1),A[Math.max(0,A.length-1)]+=e.increment)}));var a=[];return n&&i.forEach((function(e){var A=t.counters[e.counter];a.push(e.counter),A||(A=t.counters[e.counter]=[]),A.push(e.reset)})),a},e}(),Yn={integers:[1e3,900,500,400,100,90,50,40,10,9,5,4,1],values:["M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"]},jn={integers:[9e3,8e3,7e3,6e3,5e3,4e3,3e3,2e3,1e3,900,800,700,600,500,400,300,200,100,90,80,70,60,50,40,30,20,10,9,8,7,6,5,4,3,2,1],values:["Ք","Փ","Ւ","Ց","Ր","Տ","Վ","Ս","Ռ","Ջ","Պ","Չ","Ո","Շ","Ն","Յ","Մ","Ճ","Ղ","Ձ","Հ","Կ","Ծ","Խ","Լ","Ի","Ժ","Թ","Ը","Է","Զ","Ե","Դ","Գ","Բ","Ա"]},_n={integers:[1e4,9e3,8e3,7e3,6e3,5e3,4e3,3e3,2e3,1e3,400,300,200,100,90,80,70,60,50,40,30,20,19,18,17,16,15,10,9,8,7,6,5,4,3,2,1],values:["י׳","ט׳","ח׳","ז׳","ו׳","ה׳","ד׳","ג׳","ב׳","א׳","ת","ש","ר","ק","צ","פ","ע","ס","נ","מ","ל","כ","יט","יח","יז","טז","טו","י","ט","ח","ז","ו","ה","ד","ג","ב","א"]},Jn={integers:[1e4,9e3,8e3,7e3,6e3,5e3,4e3,3e3,2e3,1e3,900,800,700,600,500,400,300,200,100,90,80,70,60,50,40,30,20,10,9,8,7,6,5,4,3,2,1],values:["ჵ","ჰ","ჯ","ჴ","ხ","ჭ","წ","ძ","ც","ჩ","შ","ყ","ღ","ქ","ფ","ჳ","ტ","ს","რ","ჟ","პ","ო","ჲ","ნ","მ","ლ","კ","ი","თ","ჱ","ზ","ვ","ე","დ","გ","ბ","ა"]},Zn=function(e,t,A,i,n,a){return eA?ra(e,n,a.length>0):i.integers.reduce((function(t,A,n){for(;e>=A;)e-=A,t+=i.values[n];return t}),"")+a},qn=function(e,t,A,i){var n="";do{A||e--,n=i(e)+n,e/=t}while(e*t>=t);return n},$n=function(e,t,A,i,n){var a=A-t+1;return(e<0?"-":"")+(qn(Math.abs(e),a,i,(function(e){return l(Math.floor(e%a)+t)}))+n)},ea=function(e,t,A){void 0===A&&(A=". ");var i=t.length;return qn(Math.abs(e),i,!1,(function(e){return t[Math.floor(e%i)]}))+A},ta=function(e,t,A,i,n,a){if(e<-9999||e>9999)return ra(e,4,n.length>0);var r=Math.abs(e),s=n;if(0===r)return t[0]+s;for(var o=0;r>0&&o<=4;o++){var l=r%10;0===l&&li(a,1)&&""!==s?s=t[l]+s:l>1||1===l&&0===o||1===l&&1===o&&li(a,2)||1===l&&1===o&&li(a,4)&&e>100||1===l&&o>1&&li(a,8)?s=t[l]+(o>0?A[o-1]:"")+s:1===l&&o>0&&(s=A[o-1]+s),r=Math.floor(r/10)}return(e<0?i:"")+s},Aa="十百千萬",ia="拾佰仟萬",na="マイナス",aa="마이너스",ra=function(e,t,A){var i=A?". ":"",n=A?"、":"",a=A?", ":"",r=A?" ":"";switch(t){case 0:return"•"+r;case 1:return"◦"+r;case 2:return"◾"+r;case 5:var s=$n(e,48,57,!0,i);return s.length<4?"0"+s:s;case 4:return ea(e,"〇一二三四五六七八九",n);case 6:return Zn(e,1,3999,Yn,3,i).toLowerCase();case 7:return Zn(e,1,3999,Yn,3,i);case 8:return $n(e,945,969,!1,i);case 9:return $n(e,97,122,!1,i);case 10:return $n(e,65,90,!1,i);case 11:return $n(e,1632,1641,!0,i);case 12:case 49:return Zn(e,1,9999,jn,3,i);case 35:return Zn(e,1,9999,jn,3,i).toLowerCase();case 13:return $n(e,2534,2543,!0,i);case 14:case 30:return $n(e,6112,6121,!0,i);case 15:return ea(e,"子丑寅卯辰巳午未申酉戌亥",n);case 16:return ea(e,"甲乙丙丁戊己庚辛壬癸",n);case 17:case 48:return ta(e,"零一二三四五六七八九",Aa,"負",n,14);case 47:return ta(e,"零壹貳參肆伍陸柒捌玖",ia,"負",n,15);case 42:return ta(e,"零一二三四五六七八九",Aa,"负",n,14);case 41:return ta(e,"零壹贰叁肆伍陆柒捌玖",ia,"负",n,15);case 26:return ta(e,"〇一二三四五六七八九","十百千万",na,n,0);case 25:return ta(e,"零壱弐参四伍六七八九","拾百千万",na,n,7);case 31:return ta(e,"영일이삼사오육칠팔구","십백천만",aa,a,7);case 33:return ta(e,"零一二三四五六七八九","十百千萬",aa,a,0);case 32:return ta(e,"零壹貳參四五六七八九","拾百千",aa,a,7);case 18:return $n(e,2406,2415,!0,i);case 20:return Zn(e,1,19999,Jn,3,i);case 21:return $n(e,2790,2799,!0,i);case 22:return $n(e,2662,2671,!0,i);case 22:return Zn(e,1,10999,_n,3,i);case 23:return ea(e,"あいうえおかきくけこさしすせそたちつてとなにぬねのはひふへほまみむめもやゆよらりるれろわゐゑをん");case 24:return ea(e,"いろはにほへとちりぬるをわかよたれそつねならむうゐのおくやまけふこえてあさきゆめみしゑひもせす");case 27:return $n(e,3302,3311,!0,i);case 28:return ea(e,"アイウエオカキクケコサシスセソタチツテトナニヌネノハヒフヘホマミムメモヤユヨラリルレロワヰヱヲン",n);case 29:return ea(e,"イロハニホヘトチリヌルヲワカヨタレソツネナラムウヰノオクヤマケフコエテアサキユメミシヱヒモセス",n);case 34:return $n(e,3792,3801,!0,i);case 37:return $n(e,6160,6169,!0,i);case 38:return $n(e,4160,4169,!0,i);case 39:return $n(e,2918,2927,!0,i);case 40:return $n(e,1776,1785,!0,i);case 43:return $n(e,3046,3055,!0,i);case 44:return $n(e,3174,3183,!0,i);case 45:return $n(e,3664,3673,!0,i);case 46:return $n(e,3872,3881,!0,i);default:return $n(e,48,57,!0,i)}},sa="data-html2canvas-ignore",oa=function(){function e(e,t,A){if(this.context=e,this.options=A,this.scrolledElements=[],this.referenceElement=t,this.counters=new Xn,this.quoteDepth=0,!t.ownerDocument)throw new Error("Cloned element does not have an owner document");this.documentElement=this.cloneNode(t.ownerDocument.documentElement,!1)}return e.prototype.toIFrame=function(e,t){var A=this,a=ca(e,t);if(!a.contentWindow)return Promise.reject("Unable to find iframe window");var r=e.defaultView.pageXOffset,s=e.defaultView.pageYOffset,o=a.contentWindow,l=o.document,c=ua(a).then((function(){return i(A,void 0,void 0,(function(){var e,A;return n(this,(function(i){switch(i.label){case 0:return this.scrolledElements.forEach(fa),o&&(o.scrollTo(t.left,t.top),!/(iPad|iPhone|iPod)/g.test(navigator.userAgent)||o.scrollY===t.top&&o.scrollX===t.left||(this.context.logger.warn("Unable to restore scroll position for cloned document"),this.context.windowBounds=this.context.windowBounds.add(o.scrollX-t.left,o.scrollY-t.top,0,0))),e=this.options.onclone,void 0===(A=this.clonedReferenceElement)?[2,Promise.reject("Error finding the "+this.referenceElement.nodeName+" in the cloned document")]:l.fonts&&l.fonts.ready?[4,l.fonts.ready]:[3,2];case 1:i.sent(),i.label=2;case 2:return/(AppleWebKit)/g.test(navigator.userAgent)?[4,ha(l)]:[3,4];case 3:i.sent(),i.label=4;case 4:return"function"==typeof e?[2,Promise.resolve().then((function(){return e(l,A)})).then((function(){return a}))]:[2,a]}}))}))}));return l.open(),l.write(ma(document.doctype)+""),wa(this.referenceElement.ownerDocument,r,s),l.replaceChild(l.adoptNode(this.documentElement),l.documentElement),l.close(),c},e.prototype.createElementClone=function(e){if(yi(e,2),Dn(e))return this.createCanvasClone(e);if(Rn(e))return this.createVideoClone(e);if(Vn(e))return this.createStyleClone(e);var t=e.cloneNode(!1);return Hn(t)&&(Hn(e)&&e.currentSrc&&e.currentSrc!==e.src&&(t.src=e.currentSrc,t.srcset=""),"lazy"===t.loading&&(t.loading="eager")),zn(t)?this.createCustomElementClone(t):t},e.prototype.createCustomElementClone=function(e){var t=document.createElement("html2canvascustomelement");return pa(e.style,t),t},e.prototype.createStyleClone=function(e){try{var t=e.sheet;if(t&&t.cssRules){var A=[].slice.call(t.cssRules,0).reduce((function(e,t){return t&&"string"==typeof t.cssText?e+t.cssText:e}),""),i=e.cloneNode(!1);return i.textContent=A,i}}catch(e){if(this.context.logger.error("Unable to access cssRules property",e),"SecurityError"!==e.name)throw e}return e.cloneNode(!1)},e.prototype.createCanvasClone=function(e){var t;if(this.options.inlineImages&&e.ownerDocument){var A=e.ownerDocument.createElement("img");try{return A.src=e.toDataURL(),A}catch(t){this.context.logger.info("Unable to inline canvas contents, canvas is tainted",e)}}var i=e.cloneNode(!1);try{i.width=e.width,i.height=e.height;var n=e.getContext("2d"),a=i.getContext("2d");if(a)if(!this.options.allowTaint&&n)a.putImageData(n.getImageData(0,0,e.width,e.height),0,0);else{var r=null!==(t=e.getContext("webgl2"))&&void 0!==t?t:e.getContext("webgl");if(r){var s=r.getContextAttributes();!1===(null==s?void 0:s.preserveDrawingBuffer)&&this.context.logger.warn("Unable to clone WebGL context as it has preserveDrawingBuffer=false",e)}a.drawImage(e,0,0)}return i}catch(t){this.context.logger.info("Unable to clone canvas as it is tainted",e)}return i},e.prototype.createVideoClone=function(e){var t=e.ownerDocument.createElement("canvas");t.width=e.offsetWidth,t.height=e.offsetHeight;var A=t.getContext("2d");try{return A&&(A.drawImage(e,0,0,t.width,t.height),this.options.allowTaint||A.getImageData(0,0,t.width,t.height)),t}catch(t){this.context.logger.info("Unable to clone video as it is tainted",e)}var i=e.ownerDocument.createElement("canvas");return i.width=e.offsetWidth,i.height=e.offsetHeight,i},e.prototype.appendChildNode=function(e,t,A){In(t)&&("SCRIPT"===t.tagName||t.hasAttribute(sa)||"function"==typeof this.options.ignoreElements&&this.options.ignoreElements(t))||this.options.copyStyles&&In(t)&&Vn(t)||e.appendChild(this.cloneNode(t,A))},e.prototype.cloneChildNodes=function(e,t,A){for(var i=this,n=e.shadowRoot?e.shadowRoot.firstChild:e.firstChild;n;n=n.nextSibling)if(In(n)&&Wn(n)&&"function"==typeof n.assignedNodes){var a=n.assignedNodes();a.length&&a.forEach((function(e){return i.appendChildNode(t,e,A)}))}else this.appendChildNode(t,n,A)},e.prototype.cloneNode=function(e,t){if(Tn(e))return document.createTextNode(e.data);if(!e.ownerDocument)return e.cloneNode(!1);var A=e.ownerDocument.defaultView;if(A&&In(e)&&(kn(e)||Un(e))){var i=this.createElementClone(e);i.style.transitionProperty="none";var n=A.getComputedStyle(e),a=A.getComputedStyle(e,":before"),r=A.getComputedStyle(e,":after");this.referenceElement===e&&kn(i)&&(this.clonedReferenceElement=i),Nn(i)&&va(i);var s=this.counters.parse(new vi(this.context,n)),o=this.resolvePseudoContent(e,i,a,Li.BEFORE);zn(e)&&(t=!0),Rn(e)||this.cloneChildNodes(e,i,t),o&&i.insertBefore(o,i.firstChild);var l=this.resolvePseudoContent(e,i,r,Li.AFTER);return l&&i.appendChild(l),this.counters.pop(s),(n&&(this.options.copyStyles||Un(e))&&!Pn(e)||t)&&pa(n,i),0===e.scrollTop&&0===e.scrollLeft||this.scrolledElements.push([i,e.scrollLeft,e.scrollTop]),(Kn(e)||Gn(e))&&(Kn(i)||Gn(i))&&(i.value=e.value),i}return e.cloneNode(!1)},e.prototype.resolvePseudoContent=function(e,t,A,i){var n=this;if(A){var a=A.content,r=t.ownerDocument;if(r&&a&&"none"!==a&&"-moz-alt-content"!==a&&"none"!==A.display){this.counters.parse(new vi(this.context,A));var s=new bi(this.context,A),o=r.createElement("html2canvaspseudoelement");pa(A,o),s.content.forEach((function(t){if(0===t.type)o.appendChild(r.createTextNode(t.value));else if(22===t.type){var A=r.createElement("img");A.src=t.value,A.style.opacity="1",o.appendChild(A)}else if(18===t.type){if("attr"===t.name){var i=t.values.filter(ze);i.length&&o.appendChild(r.createTextNode(e.getAttribute(i[0].value)||""))}else if("counter"===t.name){var a=t.values.filter(_e),l=a[0],c=a[1];if(l&&ze(l)){var d=n.counters.getCounterValue(l.value),h=c&&ze(c)?IA.parse(n.context,c.value):3;o.appendChild(r.createTextNode(ra(d,h,!1)))}}else if("counters"===t.name){var u=t.values.filter(_e),g=(l=u[0],u[1]);if(c=u[2],l&&ze(l)){var p=n.counters.getCounterValues(l.value),m=c&&ze(c)?IA.parse(n.context,c.value):3,w=g&&0===g.type?g.value:"",f=p.map((function(e){return ra(e,m,!1)})).join(w);o.appendChild(r.createTextNode(f))}}}else if(20===t.type)switch(t.value){case"open-quote":o.appendChild(r.createTextNode(pi(s.quotes,n.quoteDepth++,!0)));break;case"close-quote":o.appendChild(r.createTextNode(pi(s.quotes,--n.quoteDepth,!1)));break;default:o.appendChild(r.createTextNode(t.value))}})),o.className=Ea+" "+Ba;var l=i===Li.BEFORE?" "+Ea:" "+Ba;return Un(t)?t.className.baseValue+=l:t.className+=l,o}}},e.destroy=function(e){return!!e.parentNode&&(e.parentNode.removeChild(e),!0)},e}();!function(e){e[e.BEFORE=0]="BEFORE",e[e.AFTER=1]="AFTER"}(Li||(Li={}));var la,ca=function(e,t){var A=e.createElement("iframe");return A.className="html2canvas-container",A.style.visibility="hidden",A.style.position="fixed",A.style.left="-10000px",A.style.top="0px",A.style.border="0",A.width=t.width.toString(),A.height=t.height.toString(),A.scrolling="no",A.setAttribute(sa,"true"),e.body.appendChild(A),A},da=function(e){return new Promise((function(t){e.complete?t():e.src?(e.onload=t,e.onerror=t):t()}))},ha=function(e){return Promise.all([].slice.call(e.images,0).map(da))},ua=function(e){return new Promise((function(t,A){var i=e.contentWindow;if(!i)return A("No window assigned for iframe");var n=i.document;i.onload=e.onload=function(){i.onload=e.onload=null;var A=setInterval((function(){n.body.childNodes.length>0&&"complete"===n.readyState&&(clearInterval(A),t(e))}),50)}}))},ga=["all","d","content"],pa=function(e,t){for(var A=e.length-1;A>=0;A--){var i=e.item(A);-1===ga.indexOf(i)&&t.style.setProperty(i,e.getPropertyValue(i))}return t},ma=function(e){var t="";return e&&(t+=""),t},wa=function(e,t,A){e&&e.defaultView&&(t!==e.defaultView.pageXOffset||A!==e.defaultView.pageYOffset)&&e.defaultView.scrollTo(t,A)},fa=function(e){var t=e[0],A=e[1],i=e[2];t.scrollLeft=A,t.scrollTop=i},Ea="___html2canvas___pseudoelement_before",Ba="___html2canvas___pseudoelement_after",ba='{\n content: "" !important;\n display: none !important;\n}',va=function(e){Ca(e,"."+Ea+":before"+ba+"\n ."+Ba+":after"+ba)},Ca=function(e,t){var A=e.ownerDocument;if(A){var i=A.createElement("style");i.textContent=t,e.appendChild(i)}},ya=function(){function e(){}return e.getOrigin=function(t){var A=e._link;return A?(A.href=t,A.href=A.href,A.protocol+A.hostname+A.port):"about:blank"},e.isSameOrigin=function(t){return e.getOrigin(t)===e._origin},e.setContext=function(t){e._link=t.document.createElement("a"),e._origin=e.getOrigin(t.location.href)},e._origin="about:blank",e}(),Fa=function(){function e(e,t){this.context=e,this._options=t,this._cache={}}return e.prototype.addImage=function(e){var t=Promise.resolve();return this.has(e)?t:Qa(e)||Ia(e)?((this._cache[e]=this.loadImage(e)).catch((function(){})),t):t},e.prototype.match=function(e){return this._cache[e]},e.prototype.loadImage=function(e){return i(this,void 0,void 0,(function(){var t,A,i,a,r=this;return n(this,(function(n){switch(n.label){case 0:return t=ya.isSameOrigin(e),A=!ka(e)&&!0===this._options.useCORS&&ji.SUPPORT_CORS_IMAGES&&!t,i=!ka(e)&&!t&&!Qa(e)&&"string"==typeof this._options.proxy&&ji.SUPPORT_CORS_XHR&&!A,t||!1!==this._options.allowTaint||ka(e)||Qa(e)||i||A?(a=e,i?[4,this.proxy(a)]:[3,2]):[2];case 1:a=n.sent(),n.label=2;case 2:return this.context.logger.debug("Added image "+e.substring(0,256)),[4,new Promise((function(e,t){var i=new Image;i.onload=function(){return e(i)},i.onerror=t,(Ua(a)||A)&&(i.crossOrigin="anonymous"),i.src=a,!0===i.complete&&setTimeout((function(){return e(i)}),500),r._options.imageTimeout>0&&setTimeout((function(){return t("Timed out ("+r._options.imageTimeout+"ms) loading image")}),r._options.imageTimeout)}))];case 3:return[2,n.sent()]}}))}))},e.prototype.has=function(e){return void 0!==this._cache[e]},e.prototype.keys=function(){return Promise.resolve(Object.keys(this._cache))},e.prototype.proxy=function(e){var t=this,A=this._options.proxy;if(!A)throw new Error("No proxy defined");var i=e.substring(0,256);return new Promise((function(n,a){var r=ji.SUPPORT_RESPONSE_TYPE?"blob":"text",s=new XMLHttpRequest;s.onload=function(){if(200===s.status)if("text"===r)n(s.response);else{var e=new FileReader;e.addEventListener("load",(function(){return n(e.result)}),!1),e.addEventListener("error",(function(e){return a(e)}),!1),e.readAsDataURL(s.response)}else a("Failed to proxy resource "+i+" with status code "+s.status)},s.onerror=a;var o=A.indexOf("?")>-1?"&":"?";if(s.open("GET",""+A+o+"url="+encodeURIComponent(e)+"&responseType="+r),"text"!==r&&s instanceof XMLHttpRequest&&(s.responseType=r),t._options.imageTimeout){var l=t._options.imageTimeout;s.timeout=l,s.ontimeout=function(){return a("Timed out ("+l+"ms) proxying "+i)}}s.send()}))},e}(),xa=/^data:image\/svg\+xml/i,Sa=/^data:image\/.*;base64,/i,Ta=/^data:image\/.*/i,Ia=function(e){return ji.SUPPORT_SVG_DRAWING||!Oa(e)},ka=function(e){return Ta.test(e)},Ua=function(e){return Sa.test(e)},Qa=function(e){return"blob"===e.substr(0,4)},Oa=function(e){return"svg"===e.substr(-3).toLowerCase()||xa.test(e)},La=function(){function e(e,t){this.type=0,this.x=e,this.y=t}return e.prototype.add=function(t,A){return new e(this.x+t,this.y+A)},e}(),Ma=function(e,t,A){return new La(e.x+(t.x-e.x)*A,e.y+(t.y-e.y)*A)},Na=function(){function e(e,t,A,i){this.type=1,this.start=e,this.startControl=t,this.endControl=A,this.end=i}return e.prototype.subdivide=function(t,A){var i=Ma(this.start,this.startControl,t),n=Ma(this.startControl,this.endControl,t),a=Ma(this.endControl,this.end,t),r=Ma(i,n,t),s=Ma(n,a,t),o=Ma(r,s,t);return A?new e(this.start,i,r,o):new e(o,s,a,this.end)},e.prototype.add=function(t,A){return new e(this.start.add(t,A),this.startControl.add(t,A),this.endControl.add(t,A),this.end.add(t,A))},e.prototype.reverse=function(){return new e(this.end,this.endControl,this.startControl,this.start)},e}(),Da=function(e){return 1===e.type},Ra=function(e){var t=e.styles,A=e.bounds,i=nt(t.borderTopLeftRadius,A.width,A.height),n=i[0],a=i[1],r=nt(t.borderTopRightRadius,A.width,A.height),s=r[0],o=r[1],l=nt(t.borderBottomRightRadius,A.width,A.height),c=l[0],d=l[1],h=nt(t.borderBottomLeftRadius,A.width,A.height),u=h[0],g=h[1],p=[];p.push((n+s)/A.width),p.push((u+c)/A.width),p.push((a+g)/A.height),p.push((o+d)/A.height);var m=Math.max.apply(Math,p);m>1&&(n/=m,a/=m,s/=m,o/=m,c/=m,d/=m,u/=m,g/=m);var w=A.width-s,f=A.height-d,E=A.width-c,B=A.height-g,b=t.borderTopWidth,v=t.borderRightWidth,C=t.borderBottomWidth,y=t.borderLeftWidth,F=at(t.paddingTop,e.bounds.width),x=at(t.paddingRight,e.bounds.width),S=at(t.paddingBottom,e.bounds.width),T=at(t.paddingLeft,e.bounds.width);this.topLeftBorderDoubleOuterBox=n>0||a>0?Ha(A.left+y/3,A.top+b/3,n-y/3,a-b/3,la.TOP_LEFT):new La(A.left+y/3,A.top+b/3),this.topRightBorderDoubleOuterBox=n>0||a>0?Ha(A.left+w,A.top+b/3,s-v/3,o-b/3,la.TOP_RIGHT):new La(A.left+A.width-v/3,A.top+b/3),this.bottomRightBorderDoubleOuterBox=c>0||d>0?Ha(A.left+E,A.top+f,c-v/3,d-C/3,la.BOTTOM_RIGHT):new La(A.left+A.width-v/3,A.top+A.height-C/3),this.bottomLeftBorderDoubleOuterBox=u>0||g>0?Ha(A.left+y/3,A.top+B,u-y/3,g-C/3,la.BOTTOM_LEFT):new La(A.left+y/3,A.top+A.height-C/3),this.topLeftBorderDoubleInnerBox=n>0||a>0?Ha(A.left+2*y/3,A.top+2*b/3,n-2*y/3,a-2*b/3,la.TOP_LEFT):new La(A.left+2*y/3,A.top+2*b/3),this.topRightBorderDoubleInnerBox=n>0||a>0?Ha(A.left+w,A.top+2*b/3,s-2*v/3,o-2*b/3,la.TOP_RIGHT):new La(A.left+A.width-2*v/3,A.top+2*b/3),this.bottomRightBorderDoubleInnerBox=c>0||d>0?Ha(A.left+E,A.top+f,c-2*v/3,d-2*C/3,la.BOTTOM_RIGHT):new La(A.left+A.width-2*v/3,A.top+A.height-2*C/3),this.bottomLeftBorderDoubleInnerBox=u>0||g>0?Ha(A.left+2*y/3,A.top+B,u-2*y/3,g-2*C/3,la.BOTTOM_LEFT):new La(A.left+2*y/3,A.top+A.height-2*C/3),this.topLeftBorderStroke=n>0||a>0?Ha(A.left+y/2,A.top+b/2,n-y/2,a-b/2,la.TOP_LEFT):new La(A.left+y/2,A.top+b/2),this.topRightBorderStroke=n>0||a>0?Ha(A.left+w,A.top+b/2,s-v/2,o-b/2,la.TOP_RIGHT):new La(A.left+A.width-v/2,A.top+b/2),this.bottomRightBorderStroke=c>0||d>0?Ha(A.left+E,A.top+f,c-v/2,d-C/2,la.BOTTOM_RIGHT):new La(A.left+A.width-v/2,A.top+A.height-C/2),this.bottomLeftBorderStroke=u>0||g>0?Ha(A.left+y/2,A.top+B,u-y/2,g-C/2,la.BOTTOM_LEFT):new La(A.left+y/2,A.top+A.height-C/2),this.topLeftBorderBox=n>0||a>0?Ha(A.left,A.top,n,a,la.TOP_LEFT):new La(A.left,A.top),this.topRightBorderBox=s>0||o>0?Ha(A.left+w,A.top,s,o,la.TOP_RIGHT):new La(A.left+A.width,A.top),this.bottomRightBorderBox=c>0||d>0?Ha(A.left+E,A.top+f,c,d,la.BOTTOM_RIGHT):new La(A.left+A.width,A.top+A.height),this.bottomLeftBorderBox=u>0||g>0?Ha(A.left,A.top+B,u,g,la.BOTTOM_LEFT):new La(A.left,A.top+A.height),this.topLeftPaddingBox=n>0||a>0?Ha(A.left+y,A.top+b,Math.max(0,n-y),Math.max(0,a-b),la.TOP_LEFT):new La(A.left+y,A.top+b),this.topRightPaddingBox=s>0||o>0?Ha(A.left+Math.min(w,A.width-v),A.top+b,w>A.width+v?0:Math.max(0,s-v),Math.max(0,o-b),la.TOP_RIGHT):new La(A.left+A.width-v,A.top+b),this.bottomRightPaddingBox=c>0||d>0?Ha(A.left+Math.min(E,A.width-y),A.top+Math.min(f,A.height-C),Math.max(0,c-v),Math.max(0,d-C),la.BOTTOM_RIGHT):new La(A.left+A.width-v,A.top+A.height-C),this.bottomLeftPaddingBox=u>0||g>0?Ha(A.left+y,A.top+Math.min(B,A.height-C),Math.max(0,u-y),Math.max(0,g-C),la.BOTTOM_LEFT):new La(A.left+y,A.top+A.height-C),this.topLeftContentBox=n>0||a>0?Ha(A.left+y+T,A.top+b+F,Math.max(0,n-(y+T)),Math.max(0,a-(b+F)),la.TOP_LEFT):new La(A.left+y+T,A.top+b+F),this.topRightContentBox=s>0||o>0?Ha(A.left+Math.min(w,A.width+y+T),A.top+b+F,w>A.width+y+T?0:s-y+T,o-(b+F),la.TOP_RIGHT):new La(A.left+A.width-(v+x),A.top+b+F),this.bottomRightContentBox=c>0||d>0?Ha(A.left+Math.min(E,A.width-(y+T)),A.top+Math.min(f,A.height+b+F),Math.max(0,c-(v+x)),d-(C+S),la.BOTTOM_RIGHT):new La(A.left+A.width-(v+x),A.top+A.height-(C+S)),this.bottomLeftContentBox=u>0||g>0?Ha(A.left+y+T,A.top+B,Math.max(0,u-(y+T)),g-(C+S),la.BOTTOM_LEFT):new La(A.left+y+T,A.top+A.height-(C+S))};!function(e){e[e.TOP_LEFT=0]="TOP_LEFT",e[e.TOP_RIGHT=1]="TOP_RIGHT",e[e.BOTTOM_RIGHT=2]="BOTTOM_RIGHT",e[e.BOTTOM_LEFT=3]="BOTTOM_LEFT"}(la||(la={}));var Ha=function(e,t,A,i,n){var a=(Math.sqrt(2)-1)/3*4,r=A*a,s=i*a,o=e+A,l=t+i;switch(n){case la.TOP_LEFT:return new Na(new La(e,l),new La(e,l-s),new La(o-r,t),new La(o,t));case la.TOP_RIGHT:return new Na(new La(e,t),new La(e+r,t),new La(o,l-s),new La(o,l));case la.BOTTOM_RIGHT:return new Na(new La(o,t),new La(o,t+s),new La(e+r,l),new La(e,l));case la.BOTTOM_LEFT:default:return new Na(new La(o,l),new La(o-r,l),new La(e,t+s),new La(e,t))}},Pa=function(e){return[e.topLeftBorderBox,e.topRightBorderBox,e.bottomRightBorderBox,e.bottomLeftBorderBox]},Va=function(e){return[e.topLeftPaddingBox,e.topRightPaddingBox,e.bottomRightPaddingBox,e.bottomLeftPaddingBox]},Ka=function(e,t,A){this.offsetX=e,this.offsetY=t,this.matrix=A,this.type=0,this.target=6},Ga=function(e,t){this.path=e,this.target=t,this.type=1},Wa=function(e){this.opacity=e,this.type=2,this.target=6},za=function(e){return 1===e.type},Xa=function(e,t){return e.length===t.length&&e.some((function(e,A){return e===t[A]}))},Ya=function(e){this.element=e,this.inlineLevel=[],this.nonInlineLevel=[],this.negativeZIndex=[],this.zeroOrAutoZIndexOrTransformedOrOpacity=[],this.positiveZIndex=[],this.nonPositionedFloats=[],this.nonPositionedInlineLevel=[]},ja=function(){function e(e,t){if(this.container=e,this.parent=t,this.effects=[],this.curves=new Ra(this.container),this.container.styles.opacity<1&&this.effects.push(new Wa(this.container.styles.opacity)),null!==this.container.styles.transform){var A=this.container.bounds.left+this.container.styles.transformOrigin[0].number,i=this.container.bounds.top+this.container.styles.transformOrigin[1].number,n=this.container.styles.transform;this.effects.push(new Ka(A,i,n))}if(0!==this.container.styles.overflowX){var a=Pa(this.curves),r=Va(this.curves);Xa(a,r)?this.effects.push(new Ga(a,6)):(this.effects.push(new Ga(a,2)),this.effects.push(new Ga(r,4)))}}return e.prototype.getEffects=function(e){for(var t=-1===[2,3].indexOf(this.container.styles.position),A=this.parent,i=this.effects.slice(0);A;){var n=A.effects.filter((function(e){return!za(e)}));if(t||0!==A.container.styles.position||!A.parent){if(i.unshift.apply(i,n),t=-1===[2,3].indexOf(A.container.styles.position),0!==A.container.styles.overflowX){var a=Pa(A.curves),r=Va(A.curves);Xa(a,r)||i.unshift(new Ga(r,6))}}else i.unshift.apply(i,n);A=A.parent}return i.filter((function(t){return li(t.target,e)}))},e}(),_a=function(e,t,A,i){e.container.elements.forEach((function(n){var a=li(n.flags,4),r=li(n.flags,2),s=new ja(n,e);li(n.styles.display,2048)&&i.push(s);var o=li(n.flags,8)?[]:i;if(a||r){var l=a||n.styles.isPositioned()?A:t,c=new Ya(s);if(n.styles.isPositioned()||n.styles.opacity<1||n.styles.isTransformed()){var d=n.styles.zIndex.order;if(d<0){var h=0;l.negativeZIndex.some((function(e,t){return d>e.element.container.styles.zIndex.order?(h=t,!1):h>0})),l.negativeZIndex.splice(h,0,c)}else if(d>0){var u=0;l.positiveZIndex.some((function(e,t){return d>=e.element.container.styles.zIndex.order?(u=t+1,!1):u>0})),l.positiveZIndex.splice(u,0,c)}else l.zeroOrAutoZIndexOrTransformedOrOpacity.push(c)}else n.styles.isFloating()?l.nonPositionedFloats.push(c):l.nonPositionedInlineLevel.push(c);_a(s,c,a?c:A,o)}else n.styles.isInlineLevel()?t.inlineLevel.push(s):t.nonInlineLevel.push(s),_a(s,t,A,o);li(n.flags,8)&&Ja(n,o)}))},Ja=function(e,t){for(var A=e instanceof dn?e.start:1,i=e instanceof dn&&e.reversed,n=0;n0&&e.intrinsicHeight>0){var i=tr(e),n=Va(t);this.path(n),this.ctx.save(),this.ctx.clip(),this.ctx.drawImage(A,0,0,e.intrinsicWidth,e.intrinsicHeight,i.left,i.top,i.width,i.height),this.ctx.restore()}},A.prototype.renderNodeContent=function(e){return i(this,void 0,void 0,(function(){var t,i,a,s,o,l,c,d,h,u,g,p,m,w,f,E,B,b;return n(this,(function(n){switch(n.label){case 0:this.applyEffects(e.getEffects(4)),t=e.container,i=e.curves,a=t.styles,s=0,o=t.textNodes,n.label=1;case 1:return s0&&y>0&&(f=i.ctx.createPattern(p,"repeat"),i.renderRepeat(B,f,x,S))):function(e){return 2===e.type}(A)&&(E=Ar(e,t,[null,null,null]),B=E[0],b=E[1],v=E[2],C=E[3],y=E[4],F=0===A.position.length?[At]:A.position,x=at(F[0],C),S=at(F[F.length-1],y),T=function(e,t,A,i,n){var a=0,r=0;switch(e.size){case 0:0===e.shape?a=r=Math.min(Math.abs(t),Math.abs(t-i),Math.abs(A),Math.abs(A-n)):1===e.shape&&(a=Math.min(Math.abs(t),Math.abs(t-i)),r=Math.min(Math.abs(A),Math.abs(A-n)));break;case 2:if(0===e.shape)a=r=Math.min(Tt(t,A),Tt(t,A-n),Tt(t-i,A),Tt(t-i,A-n));else if(1===e.shape){var s=Math.min(Math.abs(A),Math.abs(A-n))/Math.min(Math.abs(t),Math.abs(t-i)),o=It(i,n,t,A,!0),l=o[0],c=o[1];r=s*(a=Tt(l-t,(c-A)/s))}break;case 1:0===e.shape?a=r=Math.max(Math.abs(t),Math.abs(t-i),Math.abs(A),Math.abs(A-n)):1===e.shape&&(a=Math.max(Math.abs(t),Math.abs(t-i)),r=Math.max(Math.abs(A),Math.abs(A-n)));break;case 3:if(0===e.shape)a=r=Math.max(Tt(t,A),Tt(t,A-n),Tt(t-i,A),Tt(t-i,A-n));else if(1===e.shape){s=Math.max(Math.abs(A),Math.abs(A-n))/Math.max(Math.abs(t),Math.abs(t-i));var d=It(i,n,t,A,!1);l=d[0],c=d[1],r=s*(a=Tt(l-t,(c-A)/s))}}return Array.isArray(e.size)&&(a=at(e.size[0],i),r=2===e.size.length?at(e.size[1],n):a),[a,r]}(A,x,S,C,y),I=T[0],k=T[1],I>0&&k>0&&(U=i.ctx.createRadialGradient(b+x,v+S,0,b+x,v+S,I),xt(A.stops,2*I).forEach((function(e){return U.addColorStop(e.stop,gt(e.color))})),i.path(B),i.ctx.fillStyle=U,I!==k?(Q=e.bounds.left+.5*e.bounds.width,O=e.bounds.top+.5*e.bounds.height,M=1/(L=k/I),i.ctx.save(),i.ctx.translate(Q,O),i.ctx.transform(1,0,0,L,0,0),i.ctx.translate(-Q,-O),i.ctx.fillRect(b,M*(v-O)+O,C,y*M),i.ctx.restore()):i.ctx.fill())),n.label=6;case 6:return t--,[2]}}))},i=this,a=0,r=e.styles.backgroundImage.slice(0).reverse(),o.label=1;case 1:return a0?2!==l.style?[3,5]:[4,this.renderDashedDottedBorder(l.color,l.width,r,e.curves,2)]:[3,11]:[3,13];case 4:return n.sent(),[3,11];case 5:return 3!==l.style?[3,7]:[4,this.renderDashedDottedBorder(l.color,l.width,r,e.curves,3)];case 6:return n.sent(),[3,11];case 7:return 4!==l.style?[3,9]:[4,this.renderDoubleBorder(l.color,l.width,r,e.curves)];case 8:return n.sent(),[3,11];case 9:return[4,this.renderSolidBorder(l.color,r,e.curves)];case 10:n.sent(),n.label=11;case 11:r++,n.label=12;case 12:return s++,[3,3];case 13:return[2]}}))}))},A.prototype.renderDashedDottedBorder=function(e,t,A,a,r){return i(this,void 0,void 0,(function(){var i,s,o,l,c,d,h,u,g,p,m,w,f,E,B,b;return n(this,(function(n){return this.ctx.save(),i=function(e,t){switch(t){case 0:return qa(e.topLeftBorderStroke,e.topRightBorderStroke);case 1:return qa(e.topRightBorderStroke,e.bottomRightBorderStroke);case 2:return qa(e.bottomRightBorderStroke,e.bottomLeftBorderStroke);default:return qa(e.bottomLeftBorderStroke,e.topLeftBorderStroke)}}(a,A),s=Za(a,A),2===r&&(this.path(s),this.ctx.clip()),Da(s[0])?(o=s[0].start.x,l=s[0].start.y):(o=s[0].x,l=s[0].y),Da(s[1])?(c=s[1].end.x,d=s[1].end.y):(c=s[1].x,d=s[1].y),h=0===A||2===A?Math.abs(o-c):Math.abs(l-d),this.ctx.beginPath(),3===r?this.formatPath(i):this.formatPath(s.slice(0,2)),u=t<3?3*t:2*t,g=t<3?2*t:t,3===r&&(u=t,g=t),p=!0,h<=2*u?p=!1:h<=2*u+g?(u*=m=h/(2*u+g),g*=m):(w=Math.floor((h+g)/(u+g)),f=(h-w*u)/(w-1),g=(E=(h-(w+1)*u)/w)<=0||Math.abs(g-f){const a=await tex2dataURL(e,n);if(a){const e=[];e.push({mimeType:a.mimeType,id:t,dataURL:a.dataURL,created:a.created,size:a.size,hasSVGwithBitmap:!1,shouldScale:!0}),i(e,A)}};async function tex2dataURL(e,t){let A=0;for(;!t.mathjax&&!t.mathjaxLoaderFinished&&A<10;)await sleep$1(100),A++;t.mathjaxLoaderFinished||errorlog({where:"text2dataURL",fn:tex2dataURL,message:"mathjaxLoader not ready, using fallback. Try reloading Obsidian or restarting the Excalidraw plugin"});try{return await mathjaxSVG(e,t)}catch(A){await sleep$1(100);try{return await mathjaxSVG(e,t)}catch(A){await sleep$1(100);try{return await mathjaxSVG(e,t)}catch(A){return t.mathjax?new obsidian_module.Notice("Unknown error loading LaTeX. Using fallback solution. Try closing and reopening this drawing."):new obsidian_module.Notice("LaTeX support did not load. Using fallback solution. Try checking your network connection."),await mathjaxImage2html(e)}}}}async function mathjaxSVG(e,t){const A=t.mathjax.tex2svg(e,{display:!0,scale:4}).querySelector("svg");if(A){A.width.baseVal.valueInSpecifiedUnits<2&&(A.width.baseVal.valueAsString=`${(A.width.baseVal.valueInSpecifiedUnits+1).toFixed(3)}ex`);const e=svgToBase64(A.outerHTML);return{mimeType:"image/svg+xml",fileId:fileid(),dataURL:e,created:Date.now(),size:await getImageSize(e)}}return null}async function mathjaxImage2html(e){const t=document.body.createDiv();t.style.display="table";const A=window.MathJax.tex2chtml(e,{display:!0,scale:4});A.style.margin="3px",A.style.color="black";const i=A.querySelector("mjx-assistive-mml");i&&i.parentElement.removeChild(i),t.appendChild(A),window.MathJax.typeset();const n=await html2canvas(t,{backgroundColor:null});return document.body.removeChild(t),{mimeType:"image/png",fileId:fileid(),dataURL:n.toDataURL(),created:Date.now(),size:{height:n.height,width:n.width}}}const THEME_FILTER="invert(100%) hue-rotate(180deg) saturate(1.25)",markdownRendererRecursionWatcthdog=new Set,replaceSVGColors=(e,t)=>{if(!t)return e;if("string"==typeof e){for(const[A,i]of Object.entries(t)){const t=new RegExp(`fill="${A}"`,"g");e=e.replaceAll(t,`fill="${i}"`);const n=new RegExp(`stroke="${A}"`,"g");e=e.replaceAll(n,`stroke="${i}"`)}return e}const A=e=>{if(e instanceof SVGElement){const A=e.getAttribute("fill"),i=e.getAttribute("stroke");A&&t[A]&&e.setAttribute("fill",t[A]),i&&t[i]&&e.setAttribute("stroke",t[i])}for(const t of e.childNodes)A(t)};for(const t of e.childNodes)A(t);return e};class EmbeddedFile{constructor(e,t,A,i){if(this.file=null,this.isSVGwithBitmap=!1,this.img="",this.imgInverted="",this.mtime=0,this.mimeType="application/octet-stream",this.size={height:0,width:0},this.attemptCounter=0,this.isHyperlink=!1,this.colorMap=null,this.plugin=e,this.resetImage(t,A),this.file&&(this.plugin.ea.isExcalidrawFile(this.file)||"svg"===this.file.extension.toLowerCase()))try{this.colorMap=i?JSON.parse(i):null}catch(e){this.colorMap=null}}resetImage(e,t){if(this.imgInverted=this.img="",this.mtime=0,t.startsWith("https://")||t.startsWith("http://"))return this.isHyperlink=!0,void(this.hyperlink=t);this.linkParts=getLinkParts(t),this.hostPath=e,this.linkParts.path?(this.linkParts.width||(this.linkParts.width=this.plugin.settings.mdSVGwidth),this.linkParts.height||(this.linkParts.height=this.plugin.settings.mdSVGmaxHeight),this.file=app.metadataCache.getFirstLinkpathDest(this.linkParts.path,e),this.file||0==this.attemptCounter++&&new obsidian_module.Notice(`Excalidraw Warning: could not find image file: ${t}`,5e3)):new obsidian_module.Notice(`Excalidraw Error\nIncorrect embedded filename: ${t}`)}fileChanged(){return!this.isHyperlink&&(this.file||(this.file=app.metadataCache.getFirstLinkpathDest(this.linkParts.path,this.hostPath),this.file)?this.mtime!=this.file.stat.mtime:(this.attemptCounter++,!1))}setImage(e,t,A,i,n){if(this.file||this.isHyperlink){switch(this.fileChanged()&&(this.imgInverted=this.img=""),this.mtime=this.isHyperlink?0:this.file.stat.mtime,this.size=A,this.mimeType=t,i&&n){case!0:this.imgInverted=e;break;case!1:this.img=e}this.isSVGwithBitmap=n}}isLoaded(e){if(!this.isHyperlink){if(!this.file&&(this.file=app.metadataCache.getFirstLinkpathDest(this.linkParts.path,this.hostPath),!this.file))return this.attemptCounter++,!0;if(this.fileChanged())return!1}return this.isSVGwithBitmap&&e?""!==this.imgInverted:""!==this.img}getImage(e){return this.file||this.isHyperlink?e&&this.isSVGwithBitmap?this.imgInverted:this.img:""}shouldScale(){return this.isHyperlink||!Boolean(this.linkParts&&this.linkParts.original&&this.linkParts.original.endsWith("|100%"))}}class EmbeddedFilesLoader{constructor(e,t){this.pdfDocsMap=new Map,this.terminate=!1,this.plugin=e,this.isDark=t,this.uid=nanoid()}emptyPDFDocsMap(){this.pdfDocsMap.forEach((e=>e.destroy())),this.pdfDocsMap.clear()}async getObsidianImage(e,t){const A=await this._getObsidianImage(e,t);return this.emptyPDFDocsMap(),A}async _getObsidianImage(e,t){var A;if(!this.plugin||!e)return null;const i=e instanceof EmbeddedFile&&e.isHyperlink,n=e instanceof EmbeddedFile?e.hyperlink:"",a=e instanceof EmbeddedFile?e.file:e;if(a&&markdownRendererRecursionWatcthdog.has(a))return new obsidian_module.Notice(`Loading of ${a.path}. Please check if there is an inifinite loop of one file embedded in the other.`),null;const r=i?null:e instanceof EmbeddedFile?e.linkParts:{original:a.path,path:a.path,isBlockRef:!1,ref:null,width:this.plugin.settings.mdSVGwidth,height:this.plugin.settings.mdSVGmaxHeight,page:null};let s=!1;const o=!i&&this.plugin.isExcalidrawFile(a),l=!i&&"pdf"===a.extension.toLowerCase();if(!(i||l||IMAGE_TYPES.contains(a.extension)||o||"md"===a.extension))return null;const c=i||l?null:await app.vault.readBinary(a),d=o?await(async A=>{const i=hasExportTheme(this.plugin,a)?getExportTheme(this.plugin,a,"light"):void 0,n={withBackground:!!hasExportBackground(this.plugin,a)&&getWithBackground(this.plugin,a),withTheme:!!i},r=replaceSVGColors(await createSVG(a.path,!0,n,this,i,null,null,[],this.plugin,t+1,getExportPadding(this.plugin,a)),e instanceof EmbeddedFile?e.colorMap:null),o=r.querySelectorAll("image:not([href^='data:image/svg'])");return o.length>0&&(s=!0),s&&A&&o.forEach((e=>{var t;const A=null===(t=e.parentElement)||void 0===t?void 0:t.id;r.querySelectorAll(`use[href='#${A}']`).forEach((e=>{e.setAttribute("filter",THEME_FILTER)}))})),!s&&r.getAttribute("hasbitmap")&&(s=!0),svgToBase64(r.outerHTML)})(this.isDark):null,[h,u]=l?await this.pdfToDataURL(a,r):[null,null];let g=l?"image/png":"image/svg+xml";const p=i?getURLImageExtension(n):a.extension;o||l||(g=getMimeType(p));let m=i?e instanceof EmbeddedFile?await getDataURLFromURL(e.hyperlink,g):null:null!==(A=null!=d?d:h)&&void 0!==A?A:"svg"===a.extension?await getSVGData(app,a,e instanceof EmbeddedFile?e.colorMap:null):"md"===a.extension?null:await getDataURL(c,g);if(!i&&!m){markdownRendererRecursionWatcthdog.add(a);const e=await this.convertMarkdownToSVG(this.plugin,a,r,t);markdownRendererRecursionWatcthdog.delete(a),m=e.dataURL,s=e.hasSVGwithBitmap}try{const e=l?u:await getImageSize(m);return{mimeType:g,fileId:await generateIdFromFile(i||l?(new TextEncoder).encode(m):c),dataURL:m,created:i?0:a.stat.mtime,hasSVGwithBitmap:s,size:e}}catch(e){return null}}async loadSceneFiles(e,t,A){var i,n;if(A>4)return void new obsidian_module.Notice(t$d("INFINITE_LOOP_WARNING")+A.toString(),6e3);const a=e.getFileEntries();let r;void 0===this.isDark&&(this.isDark="dark"===(null===(n=null===(i=null==e?void 0:e.scene)||void 0===i?void 0:i.appState)||void 0===n?void 0:n.theme));const s=[];for(;!this.terminate&&!(r=a.next()).done;){const e=r.value[1];if(e.isLoaded(this.isDark)){if(e.isSVGwithBitmap){const A={mimeType:e.mimeType,id:r.value[0],dataURL:e.getImage(this.isDark),created:e.mtime,size:e.size,hasSVGwithBitmap:e.isSVGwithBitmap,shouldScale:e.shouldScale()};try{t([A],this.isDark,!1)}catch(e){errorlog({where:"EmbeddedFileLoader.loadSceneFiles",error:e})}}}else{const i=await this._getObsidianImage(e,A);if(i){const A={mimeType:i.mimeType,id:r.value[0],dataURL:i.dataURL,created:i.created,size:i.size,hasSVGwithBitmap:i.hasSVGwithBitmap,shouldScale:e.shouldScale()};try{t([A],this.isDark,!1)}catch(e){errorlog({where:"EmbeddedFileLoader.loadSceneFiles",error:e})}}}}let o;const l=e.getEquationEntries();for(;!this.terminate&&!(o=l.next()).done;)if(!e.getEquation(o.value[0]).isLoaded){const e=o.value[1].latex,t=await tex2dataURL(e,this.plugin);if(t){const e={mimeType:t.mimeType,id:o.value[0],dataURL:t.dataURL,created:t.created,size:t.size,hasSVGwithBitmap:!1,shouldScale:!0};s.push(e)}}if(this.emptyPDFDocsMap(),!this.terminate)try{t(s,this.isDark,!0)}catch(e){errorlog({where:"EmbeddedFileLoader.loadSceneFiles",error:e})}}async pdfToDataURL(e,t){var A,i;try{let n=0,a=0;const r=null!==(A=this.pdfDocsMap.get(e.path))&&void 0!==A?A:await getPDFDoc(e);this.pdfDocsMap.has(e.path)||this.pdfDocsMap.set(e.path,r);const s=isNaN(t.page)?1:null!==(i=t.page)&&void 0!==i?i:1,o=this.plugin.settings.pdfScale,l=async e=>{const t=createEl("canvas"),A=t.getContext("2d"),i=await r.getPage(e),s=i.getViewport({scale:o});a=t.height=s.height,n=t.width=s.width;const l={canvasContext:A,background:"rgba(0,0,0,0)",viewport:s};return await i.render(l).promise,t},c=await l(s);if(c){const e=[`data:image/png;base64,${await new Promise(((e,t)=>{c.toBlob((async t=>{const A=await blobToBase64(t);e(A)}))}))}`,{width:n,height:a}];return c.width=0,c.height=0,e}}catch(e){return console.log(e),[null,null]}}async convertMarkdownToSVG(e,t,A,i){var n,a,r,s;let o=!1;const l=await getTransclusion(A,e.app,t);let c=(null!==(n=l.leadingHashes)&&void 0!==n?n:"")+l.contents;""===c&&(c="# Empty markdown file\nCTRL+Click here to open the file for editing in the current active pane, or CTRL+SHIFT+Click to open it in an adjacent pane.");const d=e.app.metadataCache.getFileCache(t);let h,u=e.settings.mdFont;switch((null==d?void 0:d.frontmatter)&&Boolean(d.frontmatter["excalidraw-font"])&&(u=d.frontmatter["excalidraw-font"]),u){case"Virgil":h=VIRGIL_FONT;break;case"Cascadia":h=CASCADIA_FONT;break;case"":h="";break;default:const A=await getFontDataURL(e.app,u,t.path);h=A.fontDef,u=A.fontName}(null==d?void 0:d.frontmatter)&&null!==d.frontmatter.banner&&(c=c.replace(/banner:\s*.*/,""));const g=(null==d?void 0:d.frontmatter)&&null!==(a=d.frontmatter["excalidraw-font-color"])&&void 0!==a?a:e.settings.mdFontColor;let p=(null==d?void 0:d.frontmatter)&&null!==(r=d.frontmatter["excalidraw-css"])&&void 0!==r?r:"",m=!1;if(p&&""!=p){const A=e.app.metadataCache.getFirstLinkpathDest(p,t.path);A&&(p=await e.app.vault.read(A),m=!0)}if(!m)if(e.settings.mdCSS&&""!==e.settings.mdCSS){const A=e.app.metadataCache.getFirstLinkpathDest(e.settings.mdCSS,t.path);p+=A?`\n${await e.app.vault.read(A)}`:DEFAULT_MD_EMBED_CSS}else p+=DEFAULT_MD_EMBED_CSS;const w=(null==d?void 0:d.frontmatter)&&null!==(s=d.frontmatter["excalidraw-border-color"])&&void 0!==s?s:e.settings.mdBorderColor;w&&""!==w&&!p.match(/svg/i)&&(p+=`svg{border:2px solid;color:${w};transform:scale(.95)}`);let f=` width="${A.width}px" height="100000"`,E=` width="${A.width}px" height="100%"`;const B=(e,t,A)=>`${A?``:""}${e}${t}${""!==h?``:""}`,b=createDiv();b.setAttribute("xmlns","http://www.w3.org/1999/xhtml"),b.setAttribute("class","excalidraw-md-host"),""!==u&&(b.style.fontFamily=u),b.style.overflow="auto",b.style.display="block",b.style.color=g&&""!==g?g:"initial",await obsidian_module.MarkdownRenderer.renderMarkdown(c,b,t.path,e),b.querySelectorAll(":scope > *[class^='frontmatter']").forEach((e=>b.removeChild(e)));const v=Array.from(b.querySelectorAll("span[class='internal-embed']"));for(let A=0;A{const t=e.style,A=window.getComputedStyle(e);let i="";for(const e in t)t.hasOwnProperty(e)&&(i+=`${e}: ${A[e]};`);e.setAttribute("style",i)}));const S=(new XMLSerializer).serializeToString(F),T=(new XMLSerializer).serializeToString(x);document.body.removeChild(C);const I=new DOMParser,k=I.parseFromString(B(S,T),"image/svg+xml").firstElementChild,U=createDiv();U.appendChild(k),document.body.appendChild(U);const Q=k.querySelector(".excalidraw-md-footer").scrollHeight,O=k.querySelector(".excalidraw-md-host").scrollHeight+Q,L=O<=A.height?O:A.height;document.body.removeChild(U),f=` width="${A.width}px" height="${L}px"`,E=` width="${A.width}px" height="${L}px"`,b.style.height=L-Q+"px",b.style.overflow="hidden";const M=b.querySelectorAll("img:not([src^='data:image/svg+xml'])");M.length>0&&(o=!0),o&&this.isDark&&M.forEach((e=>{e instanceof HTMLImageElement&&(e.style.filter=THEME_FILTER)}));const N=B((new XMLSerializer).serializeToString(b),'
',p);return e.ea.mostRecentMarkdownSVG=I.parseFromString(N,"image/svg+xml").firstElementChild,{dataURL:svgToBase64(N),hasSVGwithBitmap:o}}}const getSVGData=async(e,t,A)=>{const i=replaceSVGColors(await e.vault.read(t),A);return svgToBase64(i)},generateIdFromFile=async e=>{let t;try{const A=await window.crypto.subtle.digest("SHA-1",e);t=Array.from(new Uint8Array(A)).map((e=>e.toString(16).padStart(2,"0"))).join("")}catch(e){errorlog({where:"EmbeddedFileLoader.generateIdFromFile",error:e}),t=fileid()}return t};class Prompt extends obsidian_module.Modal{constructor(e,t,A,i,n){super(e),this.prompt_text=t,this.default_value=A,this.placeholder=i,this.prompt_desc=n}onOpen(){this.titleEl.setText(this.prompt_text),this.createForm()}onClose(){this.contentEl.empty()}createForm(){var e;let t=this.contentEl.createDiv();t.addClass("excalidraw-prompt-div"),this.prompt_desc&&(t=t.createDiv(),t.style.width="100%",t.createEl("p").innerHTML=this.prompt_desc);const A=t.createEl("form");A.addClass("excalidraw-prompt-form"),A.type="submit",A.onsubmit=e=>{e.preventDefault(),this.resolve(this.promptEl.value),this.close()},this.promptEl=A.createEl("input"),this.promptEl.type="text",this.promptEl.placeholder=this.placeholder,this.promptEl.value=null!==(e=this.default_value)&&void 0!==e?e:"",this.promptEl.addClass("excalidraw-prompt-input"),this.promptEl.select()}async openAndGetValue(e){this.resolve=e,this.open()}}class GenericInputPrompt extends obsidian_module.Modal{static Prompt(e,t,A,i,n,a,r,s,o,l,c){return new GenericInputPrompt(e,t,A,i,n,a,r,s,o,l,c).waitForClose}constructor(e,t,A,i,n,a,r,s,o,l,c){super(A),this.header=i,this.didSubmit=!1,this.lines=1,this.displayEditorButtons=!1,this.selectionStart=0,this.selectionEnd=0,this.selectionUpdateTimer=0,this.blockPointerInputOutsideModal=!1,this.linkBtnClickCallback=()=>{this.view.ownerWindow.clearTimeout(this.selectionUpdateTimer),this.plugin.insertLinkDialog.start(this.view.file.path,(e=>{const t=this.inputComponent.inputEl.value;this.selectionStart>0&&" "!==t.slice(this.selectionStart-1,this.selectionStart)&&(e=" "+e),this.selectionStart{this.view.ownerWindow.clearTimeout(this.selectionUpdateTimer);const t=this.inputComponent.inputEl.value.slice(0,this.selectionStart)+e+this.inputComponent.inputEl.value.slice(this.selectionStart);this.inputComponent.inputEl.value=t,this.input=this.inputComponent.inputEl.value,this.inputComponent.inputEl.focus(),this.selectionStart=this.selectionStart+1,this.selectionEnd=this.selectionStart,this.inputComponent.inputEl.setSelectionRange(this.selectionStart,this.selectionEnd)},this.delBtnClickCallback=()=>{if(this.view.ownerWindow.clearTimeout(this.selectionUpdateTimer),0===this.input.length)return;const e=this.selectionEnd>this.selectionStart?this.selectionStart:this.selectionStart>0?this.selectionStart-1:0,t=this.selectionEnd,A=this.inputComponent.inputEl.value.slice(0,e)+this.inputComponent.inputEl.value.slice(t);this.inputComponent.inputEl.value=A,this.input=this.inputComponent.inputEl.value,this.inputComponent.inputEl.focus(),this.selectionStart=e,this.selectionEnd=e,this.inputComponent.inputEl.setSelectionRange(e,e)},this.uppercaseBtnClickCallback=()=>{if(this.view.ownerWindow.clearTimeout(this.selectionUpdateTimer),this.selectionEnd===this.selectionStart)return;const e=this.inputComponent.inputEl.value.slice(0,this.selectionStart)+this.inputComponent.inputEl.value.slice(this.selectionStart,this.selectionEnd).toUpperCase()+this.inputComponent.inputEl.value.slice(this.selectionEnd);this.inputComponent.inputEl.value=e,this.input=this.inputComponent.inputEl.value,this.inputComponent.inputEl.focus(),this.inputComponent.inputEl.setSelectionRange(this.selectionStart,this.selectionEnd)},this.submitClickCallback=()=>this.submit(),this.cancelClickCallback=()=>this.cancel(),this.keyDownCallback=e=>{("Enter"===e.key&&1===this.lines||isCTRL(e)&&"Enter"===e.key)&&(e.preventDefault(),this.submit()),this.displayEditorButtons&&"k"===e.key&&isCTRL(e)&&(e.preventDefault(),this.linkBtnClickCallback())},this.view=e,this.plugin=t,this.placeholder=n,this.input=a,this.buttons=r,this.lines=null!=s?s:1,this.displayEditorButtons=this.lines>1&&null!=o&&o,this.customComponents=l,this.blockPointerInputOutsideModal=null!=c&&c,this.waitForClose=new Promise(((e,t)=>{this.resolvePromise=e,this.rejectPromise=t})),this.display(),this.inputComponent.inputEl.focus(),this.open()}display(){var e;this.contentEl.empty(),this.blockPointerInputOutsideModal&&(this.bgEl.style.pointerEvents=this.blockPointerInputOutsideModal?"none":"auto"),this.titleEl.textContent=this.header;const t=this.contentEl.createDiv();this.inputComponent=this.createInputField(t,this.placeholder,this.input),null===(e=this.customComponents)||void 0===e||e.call(this,t),this.createButtonBar(t)}createInputField(e,t,A){const i=new obsidian_module.TextAreaComponent(e);i.inputEl.style.width="100%",i.inputEl.style.height=2*this.lines+"em",1===this.lines&&(i.inputEl.style.resize="none",i.inputEl.style.overflow="hidden"),i.setPlaceholder(null!=t?t:"").setValue(null!=A?A:"").onChange((e=>this.input=e));const n=()=>{this.selectionUpdateTimer=this.view.ownerWindow.setTimeout((()=>{this.selectionStart=this.inputComponent.inputEl.selectionStart,this.selectionEnd=this.inputComponent.inputEl.selectionEnd}),30)};return i.inputEl.addEventListener("keydown",this.keyDownCallback),i.inputEl.addEventListener("keyup",n),i.inputEl.addEventListener("pointerup",n),i.inputEl.addEventListener("touchend",n),i.inputEl.addEventListener("input",n),i.inputEl.addEventListener("paste",n),i.inputEl.addEventListener("cut",n),i.inputEl.addEventListener("select",n),i.inputEl.addEventListener("selectionchange",n),i}createButton(e,t,A,i="",n="5px"){const a=new obsidian_module.ButtonComponent(e);return a.buttonEl.style.padding="0.5em",a.buttonEl.style.marginLeft=n,a.setTooltip(i),a.setButtonText(t).onClick(A),a}createButtonBar(e){const t=e.createDiv();t.style.display="flex",t.style.justifyContent="space-between",t.style.marginTop="1rem";const A=t.createDiv(),i=t.createDiv();if(this.buttons&&this.buttons.length>0){let e=null;for(const t of this.buttons){const A=new obsidian_module.ButtonComponent(i);A.buttonEl.style.marginLeft="5px",t.tooltip&&A.setTooltip(t.tooltip),A.setButtonText(t.caption).onClick((e=>{const A=t.action(this.input);A&&(this.input=A),this.submit()})),e=null!=e?e:A}e&&(e.setCta(),e.buttonEl.style.marginRight="0")}else this.createButton(i,"✅",this.submitClickCallback).setCta().buttonEl.style.marginRight="0";this.createButton(i,"❌",this.cancelClickCallback,t$d("PROMPT_BUTTON_CANCEL")),this.displayEditorButtons&&(this.createButton(A,"⏎",(()=>this.insertStringBtnClickCallback("\n")),t$d("PROMPT_BUTTON_INSERT_LINE"),"0"),this.createButton(A,"⌫",this.delBtnClickCallback,"Delete"),this.createButton(A,"⎵",(()=>this.insertStringBtnClickCallback(" ")),t$d("PROMPT_BUTTON_INSERT_SPACE")),this.view&&this.createButton(A,"🔗",this.linkBtnClickCallback,t$d("PROMPT_BUTTON_INSERT_LINK")),this.createButton(A,"🔠",this.uppercaseBtnClickCallback,t$d("PROMPT_BUTTON_UPPERCASE")))}submit(){this.didSubmit=!0,this.close()}cancel(){this.close()}resolveInput(){this.didSubmit?this.resolvePromise(this.input):this.rejectPromise("No input given.")}removeInputListener(){var e,t;null===(t=null===(e=this.inputComponent)||void 0===e?void 0:e.inputEl)||void 0===t||t.removeEventListener("keydown",this.keyDownCallback)}onOpen(){super.onOpen(),this.inputComponent.inputEl.focus(),this.inputComponent.inputEl.select()}onClose(){super.onClose(),this.resolveInput(),this.removeInputListener()}}class GenericSuggester extends obsidian_module.FuzzySuggestModal{static Suggest(e,t,A,i,n){return new GenericSuggester(e,t,A,i,n).promise}constructor(e,t,A,i,n){var a;super(e),this.displayItems=t,this.items=A,this.hint=i,this.instructions=n,this.limit=20,this.setPlaceholder(null!==(a=this.hint)&&void 0!==a?a:""),n&&this.setInstructions(this.instructions),this.promise=new Promise(((e,t)=>{this.resolvePromise=e,this.rejectPromise=t})),this.open()}getItemText(e){return this.displayItems[this.items.indexOf(e)]}getItems(){return this.items}selectSuggestion(e,t){this.resolved=!0,super.selectSuggestion(e,t)}onChooseItem(e){this.resolved=!0,this.resolvePromise(e)}onClose(){super.onClose(),this.resolved||this.rejectPromise(this.inputEl.value)}}class NewFileActions extends obsidian_module.Modal{constructor(e,t,A,i,n=!0,a){super(e.app),this.plugin=e,this.path=t,this.keys=A,this.view=i,this.openNewFile=n,this.parentFile=a,this.newFile=null,a||(this.parentFile=i.file),this.waitForClose=new Promise(((e,t)=>{this.resolvePromise=e,this.rejectPromise=t}))}onOpen(){this.createForm()}openFile(e){this.newFile=e,e&&this.openNewFile&&getLeaf(this.plugin,this.view.leaf,this.keys).openFile(e,{active:!0})}onClose(){super.onClose(),this.resolvePromise(this.newFile)}createForm(){this.titleEl.setText(t$d("PROMPT_TITLE_NEW_FILE")),this.contentEl.createDiv({cls:"excalidraw-prompt-center",text:t$d("PROMPT_FILE_DOES_NOT_EXIST")}),this.contentEl.createDiv({cls:"excalidraw-prompt-center filepath",text:this.path}),this.contentEl.createDiv({cls:"excalidraw-prompt-center"},(e=>{e.style.textAlign="right";const t=()=>this.path&&""!==this.path?!!this.parentFile||(new obsidian_module.Notice(t$d("PROMPT_ERROR_DRAWING_CLOSED")),!1):(new obsidian_module.Notice(t$d("PROMPT_ERROR_NO_FILENAME")),!1),A=async e=>{if(!this.path.includes("/")){const e=new RegExp(`${this.parentFile.name}$`,"g");this.path=this.parentFile.path.replace(e,this.path)}return this.path.match(/\.md$/)||(this.path=`${this.path}.md`),checkAndCreateFolder(splitFolderAndFilename(this.path).folderpath),await this.app.vault.create(this.path,e)};e.createEl("button",{text:t$d("PROMPT_BUTTON_CREATE_MARKDOWN")}).onclick=async()=>{if(!t)return;const e=await A("");this.openFile(e),this.close()},e.createEl("button",{text:t$d("PROMPT_BUTTON_CREATE_EXCALIDRAW")}).onclick=async()=>{if(!t)return;const e=await A(await this.plugin.getBlankDrawing());await sleep$1(200),this.openFile(e),this.close()},e.createEl("button",{text:t$d("PROMPT_BUTTON_NEVERMIND")}).onclick=()=>{this.close()}}))}}class ConfirmationPrompt extends obsidian_module.Modal{constructor(e,t){super(e.app),this.plugin=e,this.didConfirm=!1,this.cancelClickCallback=()=>{this.didConfirm=!1,this.close()},this.confirmClickCallback=()=>{this.didConfirm=!0,this.close()},this.message=t,this.waitForClose=new Promise(((e,t)=>{this.resolvePromise=e,this.rejectPromise=t})),this.display(),this.open()}display(){this.contentEl.empty(),this.titleEl.textContent=t$d("PROMPT_TITLE_CONFIRMATION");const e=this.contentEl.createDiv();e.style.marginBottom="1rem",e.innerHTML=this.message;const t=this.contentEl.createDiv();t.style.display="flex",t.style.justifyContent="flex-end";const A=this.createButton(t,t$d("PROMPT_BUTTON_CANCEL"),this.cancelClickCallback);A.buttonEl.style.marginRight="0.5rem",this.createButton(t,t$d("PROMPT_BUTTON_OK"),this.confirmClickCallback).buttonEl.style.marginRight="0",A.buttonEl.focus()}createButton(e,t,A){const i=new obsidian_module.ButtonComponent(e);return i.setButtonText(t).onClick(A),i}onOpen(){var e;super.onOpen(),null===(e=this.contentEl.querySelector("button"))||void 0===e||e.focus()}onClose(){super.onClose(),this.didConfirm?this.resolvePromise(!0):this.resolvePromise(!1)}}var AutoexportPreference;!function(e){e[e.none=0]="none",e[e.both=1]="both",e[e.png=2]="png",e[e.svg=3]="svg",e[e.inherit=4]="inherit"}(AutoexportPreference||(AutoexportPreference={}));const REGEX_LINK={ +//![[link|alias]] [alias](link){num} +EXPR:/(!)?(\[\[([^|\]]+)\|?([^\]]+)?]]|\[([^\]]*)]\(([^)]*)\))(\{(\d+)\})?/g,getResList:e=>{const t=e.matchAll(REGEX_LINK.EXPR);let A;const i=[];for(;!(A=t.next()).done;)i.push(A);return i},getRes:e=>e.matchAll(REGEX_LINK.EXPR),isTransclusion:e=>!!e.value[1],getLink:e=>e.value[3]?e.value[3]:e.value[6],isWikiLink:e=>!!e.value[3],getAliasOrLink:e=>REGEX_LINK.isWikiLink(e)?e.value[4]?e.value[4]:e.value[3]:e.value[5]?e.value[5]:e.value[6],getWrapLength:(e,t)=>{const A=parseInt(e.value[8]);return isNaN(A)?t>0?t:null:A}},DRAWING_REG=/\n# Drawing\n[^`]*(```json\n)([\s\S]*?)```\n/gm,DRAWING_REG_FALLBACK=/\n# Drawing\n(```json\n)?(.*)(```)?(%%)?/gm,DRAWING_COMPRESSED_REG=/(\n# Drawing\n[^`]*(?:```compressed\-json\n))([\s\S]*?)(```\n)/gm,DRAWING_COMPRESSED_REG_FALLBACK=/(\n# Drawing\n(?:```compressed\-json\n)?)(.*)((```)?(%%)?)/gm,REG_LINKINDEX_HYPERLINK=/^\w+:\/\//,isCompressedMD=e=>null!==e.match(/```compressed\-json\n/gm),getDecompressedScene=e=>{let t,A=e.matchAll(DRAWING_COMPRESSED_REG);return t=A.next(),t.done&&(A=e.matchAll(DRAWING_COMPRESSED_REG_FALLBACK),t=A.next()),t.value&&t.value.length>1?[decompress(t.value[2]),t]:[null,t]},changeThemeOfExcalidrawMD=e=>{const t=isCompressedMD(e);let A=t?getDecompressedScene(e)[0]:e;return A?(isObsidianThemeDark?1===(A.match(/"theme"\s*:\s*"light"\s*,/g)||[]).length&&(A=A.replace(/"theme"\s*:\s*"light"\s*,/,'"theme": "dark",')):1===(A.match(/"theme"\s*:\s*"dark"\s*,/g)||[]).length&&(A=A.replace(/"theme"\s*:\s*"dark"\s*,/,'"theme": "light",')),t?e.replace(DRAWING_COMPRESSED_REG,`$1${compress(A)}$3`):A):e};function getJSON(e){let t,A;if(isCompressedMD(e)){const[t,A]=getDecompressedScene(e);return t?{scene:t.substring(0,t.lastIndexOf("}")+1),pos:A.value.index}:{scene:e,pos:A.value?A.value.index:0}}if(t=e.matchAll(DRAWING_REG),A=t.next(),A.done&&(t=e.matchAll(DRAWING_REG_FALLBACK),A=t.next()),A.value&&A.value.length>1){const e=A.value[2];return{scene:e.substr(0,e.lastIndexOf("}")+1),pos:A.value.index}}return{scene:e,pos:A.value?A.value.index:0}}function getMarkdownDrawingSection(e,t){return t?`%%\n# Drawing\n\`\`\`compressed-json\n${compress(e)}\n\`\`\`\n%%`:`%%\n# Drawing\n\`\`\`json\n${e}\n\`\`\`\n%%`}const estimateMaxLineLen=(e,t)=>{if(!t||!e)return null;if(e===t)return null;let A=0;const i=e.split("\n");if(1===i.length)return null;for(const e of i){const t=e.trim();t.length>A&&(A=t.length)}return A},wrap=(e,t)=>t?wrapTextAtCharLength(e,t,!1,0):e;class ExcalidrawData{constructor(e){this.plugin=e,this.textElements=null,this.elementLinks=null,this.scene=null,this.deletedElements=[],this.file=null,this.embeddableTheme="auto",this.autoexportPreference=AutoexportPreference.inherit,this.textMode=TextMode.raw,this.loaded=!1,this.files=null,this.equations=null,this.compatibilityMode=!1,this.selectedElementIds={},this.disableCompression=!1,this.app=e.app,this.files=new Map,this.equations=new Map}initializeNonInitializedFields(){var e,t,A;if(!this.scene||!this.scene.elements)return;const i=null!==(e=this.scene.source.split("https://github.com/zsviczian/obsidian-excalidraw-plugin/releases/tag/")[1])&&void 0!==e?e:"1.8.16",n=this.scene.elements;for(const e of n){if("iframe"===e.type&&(e.type="embeddable"),e.boundElements){const t=new Map;e.boundElements.forEach((e=>{t.set(e.id,e.type)}));const A=Array.from(t,(([e,t])=>({id:e,type:t})));A.length!==e.boundElements.length&&(e.boundElements=A)}e.boundElementIds&&(e.boundElements||(e.boundElements=[]),e.boundElements=e.boundElements.concat(e.boundElementIds.map((e=>({type:"arrow",id:e})))),delete e.boundElementIds),"text"!==e.type||e.containerId||(e.containerId=null),null===e.x&&(e.x=0),null===e.y&&(e.y=0),null===(null===(t=e.startBinding)||void 0===t?void 0:t.focus)&&(e.startBinding.focus=0),null===(null===(A=e.endBinding)||void 0===A?void 0:A.focus)&&(e.endBinding.focus=0),null===e.fontSize&&(e.fontSize=20)}try{n.filter((e=>"text"===e.type&&e.containerId&&n.some((t=>t.id===e.containerId&&t.boundElements.length>0&&t.boundElements.some((t=>"text"===t.type&&t.id!==e.id&&t.id.length>8)))))).forEach((e=>{try{const t=n.filter((t=>t.id===e.containerId))[0],A=t.boundElements.filter((e=>!("text"===e.type&&!n.some((t=>t.id===e.id)))));t.boundElements=[{id:e.id,type:"text"}].concat(A)}catch(e){}}));const e=!isVersionNewerThanOther(i,"1.8.16");n.filter((e=>e.boundElements&&e.boundElements.length>0)).forEach((t=>{var A;e&&!(null===(A=t.customData)||void 0===A?void 0:A.legacyTextWrap)&&(t.customData=Object.assign(Object.assign({},t.customData),{legacyTextWrap:!0}));const i=t.boundElements.filter((e=>n.some((t=>t.id===e.id))));i.length!==t.boundElements.length&&(t.boundElements=i)})),n.filter((e=>"text"===e.type&&e.containerId&&!n.some((t=>t.id===e.containerId)))).forEach((e=>{e.containerId=null}))}catch(e){}}async loadData(e,t,A){var i,n;if(!t)return!1;if(this.loaded=!1,this.selectedElementIds={},this.textElements=new Map,this.elementLinks=new Map,this.file!=t&&(this.files.clear(),this.equations.clear()),this.file=t,this.compatibilityMode=!1,this.setShowLinkBrackets(),this.setLinkPrefix(),this.setUrlPrefix(),this.setAutoexportPreferences(),this.setembeddableThemePreference(),this.scene=null,this.plugin.settings.syncExcalidraw){const e=`${t.path.substring(0,t.path.lastIndexOf(".md"))}.excalidraw`,A=this.app.vault.getAbstractFileByPath(e);if(A&&A instanceof obsidian_module.TFile&&A.stat.mtime>t.stat.mtime){const e=await this.app.vault.read(A);this.scene=JSON.parse(e)}}let a=null;if(a=(()=>{const t=getJSON(e);if(-1===t.pos)throw new Error("Excalidraw JSON not found in the file");return this.scene||(this.scene=JSON_parse(t.scene)),t})(),this.deletedElements=this.scene.elements.filter((e=>e.isDeleted)),this.scene.elements=this.scene.elements.filter((e=>!e.isDeleted)),this.scene.files||(this.scene.files={}),hasExportTheme(this.plugin,this.file)?this.scene.appState.theme=getExportTheme(this.plugin,this.file,"light"):this.plugin.settings.matchThemeAlways&&(this.scene.appState.theme=isObsidianThemeDark()?"dark":"light"),null===(n=null===(i=this.scene)||void 0===i?void 0:i.elements)||void 0===n?void 0:n.some((e=>"iframe"===e.type))){const e=new ConfirmationPrompt(this.plugin,"This file contains embedded frames which will be migrated to a newer version for compatibility with excalidraw.com.
🔄 If you're using Obsidian on multiple devices, you may proceed now, but please, before opening this file on your other devices, update Excalidraw on those as well.
🔍 More info is available here.
🌐 Translate.");if(e.contentEl.focus(),!await e.waitForClose)throw new Error("iframe conversion canceled")}this.initializeNonInitializedFields();let r=(e=e.substring(0,a.pos)).search(/(^%%\n)?# Text Elements\n/m);if(-1===r)return await this.setTextMode(A,!1),this.loaded=!0,!0;r+=e.match(/((^%%\n)?# Text Elements\n)/m)[0].length,e=e.substring(r),r=0;const s=" ^12345678\n\n".length;let o,l=e.matchAll(/\s\^(.{8})[\n]+/g);for(;!(o=l.next()).done;){let t=e.substring(r,o.value.index);const A=o.value[1],i=this.scene.elements.filter((e=>e.id===A))[0];if(i)if("text"!==i.type)i.link!==t&&(i.link=t,i.version++,i.versionNonce++),this.elementLinks.set(A,t);else{const e=estimateMaxLineLen(i.text,i.originalText),n=t.matchAll(/^%%\*\*\*>>>text element-link:(\[\[[^<*\]]*]])<<<\*\*\*%%/gm).next();n.done||(t=t.replace(/^%%\*\*\*>>>text element-link:\[\[[^<*\]]*]]<<<\*\*\*%%/gm,""),i.link=n.value[1]);const a=await this.parse(t);i.rawText=t,this.textElements.set(A,{raw:t,parsed:a.parsed,wrapAt:e}),a.link&&(i.link=a.link),!i||i.rawText&&""!==i.rawText||(i.rawText=t)}r=o.value.index+s}for(l=(e=e.substring(e.indexOf("# Embedded files\n")+"# Embedded files\n".length)).matchAll(/([\w\d]*):\s*\[\[([^\]]*)]]\s?(\{[^}]*})?\n/gm);!(o=l.next()).done;){const e=new EmbeddedFile(this.plugin,this.file.path,o.value[2],o.value[3]);this.setFile(o.value[1],e)}for(l=e.matchAll(/([\w\d]*):\s*(https?:\/\/[^\s]*)\n/gm);!(o=l.next()).done;){const e=new EmbeddedFile(this.plugin,null,o.value[2]);this.setFile(o.value[1],e)}for(l=e.matchAll(/([\w\d]*):\s*\$\$(.*)(\$\$\s*\n)/gm);!(o=l.next()).done;)this.setEquation(o.value[1],{latex:o.value[2],isLoaded:!1});return this.findNewTextElementsInScene(),this.findNewElementLinksInScene(),await this.setTextMode(A,!0),this.loaded=!0,!0}async loadLegacyData(e,t){return!!t&&(this.loaded=!1,this.selectedElementIds={},this.compatibilityMode=!0,this.file=t,this.textElements=new Map,this.elementLinks=new Map,this.setShowLinkBrackets(),this.setLinkPrefix(),this.setUrlPrefix(),this.setembeddableThemePreference(),this.scene=JSON.parse(e),this.scene.files||(this.scene.files={}),this.initializeNonInitializedFields(),this.plugin.settings.matchThemeAlways&&(this.scene.appState.theme=isObsidianThemeDark()?"dark":"light"),this.files.clear(),this.equations.clear(),this.findNewTextElementsInScene(),this.findNewElementLinksInScene(),await this.setTextMode(TextMode.raw,!0),this.loaded=!0,!0)}async setTextMode(e,t=!1){this.scene&&(this.textMode=e,await this.updateSceneTextElements(t))}updateTextElement(e,t,A,i=!1,n){var a;if(i||t!=e.text){const i=_measureText(t,e.fontSize,e.fontFamily,null!==(a=e.lineHeight)&&void 0!==a?a:getDefaultLineHeight(e.fontFamily));e.text=t,e.originalText=A,e.containerId&&"arrow"!==n||(e.width=i.w),e.height=i.h,e.baseline=i.baseline}}async updateSceneTextElements(e=!1){var t,A,i,n;const a=null===(t=this.scene.elements)||void 0===t?void 0:t.filter((e=>"text"===e.type));for(const t of a){const a=getContainerElement(t,this.scene),r=null!==(i=null!==(A=await this.getText(t.id))&&void 0!==A?A:t.originalText)&&void 0!==i?i:t.text,s=null===(n=this.textElements.get(t.id))||void 0===n?void 0:n.wrapAt;try{this.updateTextElement(t,s?wrapText(r,getFontString({fontSize:t.fontSize,fontFamily:t.fontFamily}),getBoundTextMaxWidth(a)):r,r,e,null==a?void 0:a.type)}catch(e){debug({where:"ExcalidrawData.updateSceneTextElements",fn:this.updateSceneTextElements,textElement:t})}}}async getText(e){const t=this.textElements.get(e);return t?this.textMode===TextMode.parsed?(t.parsed||this.textElements.set(e,{raw:t.raw,parsed:(await this.parse(t.raw)).parsed,wrapAt:t.wrapAt}),t.parsed):t.raw:null}findNewElementLinksInScene(){var e;let t=!1;const A=null===(e=this.scene.elements)||void 0===e?void 0:e.filter((e=>"text"!==e.type&&e.link&&e.link.startsWith("[[")&&!this.elementLinks.has(e.id)));if(0===A.length)return t;let i,n=JSON.stringify(this.scene);for(const e of A)i=e.id,e.id.length>8&&(t=!0,i=nanoid(),n=n.replaceAll(e.id,i)),this.elementLinks.set(i,e.link);return this.scene=JSON.parse(n),t}findNewTextElementsInScene(e={}){var t;this.selectedElementIds=e;const A=null===(t=this.scene.elements)||void 0===t?void 0:t.filter((e=>"text"===e.type));let i,n=JSON.stringify(this.scene),a=!1;for(const e of A)if(i=e.id,e.id.length>8){if(a=!0,i=nanoid(),this.selectedElementIds[e.id]&&(delete this.selectedElementIds[e.id],this.selectedElementIds[i]=!0),n=n.replaceAll(e.id,i),this.textElements.has(e.id)){const t=this.textElements.get(e.id);this.textElements.set(i,{raw:t.raw,parsed:t.parsed,wrapAt:t.wrapAt}),this.textElements.delete(e.id)}if(!this.textElements.has(i)){const t=e.rawText&&""!==e.rawText?e.rawText:e.text,A=estimateMaxLineLen(e.text,e.originalText);this.textElements.set(i,{raw:t,parsed:null,wrapAt:A}),this.parseasync(i,t,A)}}else if(!this.textElements.has(e.id)){const t=e.rawText&&""!==e.rawText?e.rawText:e.text,A=estimateMaxLineLen(e.text,e.originalText);this.textElements.set(i,{raw:t,parsed:null,wrapAt:A}),this.parseasync(i,t,A)}return a&&(this.scene=JSON.parse(n)),a}updateElementLinksFromScene(){var e;for(const t of this.elementLinks.keys()){const A=null===(e=this.scene.elements)||void 0===e?void 0:e.filter((e=>"text"!==e.type&&e.id===t&&e.link&&e.link.startsWith("[[")));0===A.length?this.elementLinks.delete(t):this.elementLinks.set(t,A[0].link)}}async updateTextElementsFromScene(){var e,t,A;for(const i of this.textElements.keys()){const n=null===(e=this.scene.elements)||void 0===e?void 0:e.filter((e=>"text"===e.type&&e.id===i));if(0===n.length)this.textElements.delete(i);else{const e=await this.getText(i),a=this.scene.prevTextMode===TextMode.parsed?n[0].rawText:null!==(t=n[0].originalText)&&void 0!==t?t:n[0].text;if(e!==(null!==(A=n[0].originalText)&&void 0!==A?A:n[0].text)){const e=estimateMaxLineLen(n[0].text,n[0].originalText);this.textElements.set(i,{raw:a,parsed:(await this.parse(a)).parsed,wrapAt:e})}}}}async parseasync(e,t,A){this.textElements.set(e,{raw:t,parsed:(await this.parse(t)).parsed,wrapAt:A})}parseLinks(e,t,A){return e.substring(t,A.value.index)+(this.showLinkBrackets?"[[":"")+REGEX_LINK.getAliasOrLink(A)+(this.showLinkBrackets?"]]":"")}async getTransclusion(e){const t=getLinkParts(e,this.file),A=this.app.metadataCache.getFirstLinkpathDest(t.path,this.file.path);return await getTransclusion(t,this.app,A,this.plugin.settings.pageTransclusionCharLimit)}async parse(e){e=this.parseCheckbox(e);let t="",A=null,i=0;const n=REGEX_LINK.getRes(e);let a,r=!1,s=!1;for(e.match(REG_LINKINDEX_HYPERLINK)&&(A=e,s=!0);!(a=n.next()).done;){if(!A){const e=REGEX_LINK.getLink(a);A=e.match(REG_LINKINDEX_HYPERLINK)?e:`[[${e}]]`}if(REGEX_LINK.isTransclusion(a)){let A=this.parseCheckbox((await this.getTransclusion(REGEX_LINK.getLink(a))).contents).replaceAll(/%%[^%]*%%/gm,"");this.plugin.settings.removeTransclusionQuoteSigns&&(A=A.replaceAll(/\n\s*>\s?/gm,"\n")),t+=e.substring(i,a.value.index)+wrapTextAtCharLength(A,REGEX_LINK.getWrapLength(a,this.plugin.settings.wordWrappingDefault),this.plugin.settings.forceWrap)}else{const A=this.parseLinks(e,i,a);A&&(t+=A,s||r||(REGEX_LINK.getLink(a).match(REG_LINKINDEX_HYPERLINK)?s=!0:r=!0))}i=a.value.index+a.value[0].length}return t+=e.substring(i,e.length),r&&(t=this.linkPrefix+t),s&&(t=this.urlPrefix+t),{parsed:t,link:A}}parseCheckbox(e){return this.plugin.settings.parseTODO?e.replaceAll(/^- \[\s] /g,`${this.plugin.settings.todo} `).replaceAll(/\n- \[\s] /g,`\n${this.plugin.settings.todo} `).replaceAll(/^- \[[^\s]] /g,`${this.plugin.settings.done} `).replaceAll(/\n- \[[^\s]] /g,`\n${this.plugin.settings.done} `):e}quickParse(e){if((e=>{const t=REGEX_LINK.getRes(e);let A;for(;!(A=t.next()).done;)if(REGEX_LINK.isTransclusion(A))return!0;return!1})(e))return[null,null];e=this.parseCheckbox(e);let t="",A=null,i=0;const n=REGEX_LINK.getRes(e);let a,r=!1,s=!1;for(e.match(REG_LINKINDEX_HYPERLINK)&&(A=e,s=!0);!(a=n.next()).done;){if(!A){const e=REGEX_LINK.getLink(a);A=e.match(REG_LINKINDEX_HYPERLINK)?e:`[[${e}]]`}const n=this.parseLinks(e,i,a);n&&(t+=n,s||r||(REGEX_LINK.getLink(a).match(REG_LINKINDEX_HYPERLINK)?s=!0:r=!0)),i=a.value.index+a.value[0].length}return t+=e.substring(i,e.length),r&&(t=this.linkPrefix+t),s&&(t=this.urlPrefix+t),[t,A]}generateMD(e=[]){let t="# Text Elements\n";for(const e of this.textElements.keys()){const A=this.scene.elements.filter((t=>t.id===e));let i=this.textElements.get(e).raw;A&&1===A.length&&A[0].link&&A[0].rawText===A[0].originalText&&A[0].link.match(/^\[\[[^\]]*]]$/g)&&(i=`%%***>>>text element-link:${A[0].link}<<<***%%`+i),t+=`${i} ^${e}\n\n`}for(const e of this.elementLinks.keys())t+=`${this.elementLinks.get(e)} ^${e}\n\n`;if(t+=this.equations.size>0||this.files.size>0?"\n# Embedded files\n":"",this.equations.size>0)for(const e of this.equations.keys())t+=`${e}: $$${this.equations.get(e).latex}$$\n`;if(this.files.size>0)for(const e of this.files.keys()){const A=/(^[^#\|]*)/,i=this.files.get(e);i.isHyperlink?t+=`${e}: ${i.hyperlink}\n`:t+=`${e}: [[${i.file?i.linkParts.original.replace(A,app.metadataCache.fileToLinktext(i.file,this.file.path)):i.linkParts.original}]]${i.colorMap?" "+JSON.stringify(i.colorMap):""}\n`}return t+=this.equations.size>0||this.files.size>0?"\n":"",t+getMarkdownDrawingSection(JSON.stringify({type:this.scene.type,version:this.scene.version,source:this.scene.source,elements:this.scene.elements.concat(e),appState:this.scene.appState,files:this.scene.files},null,"\t"),!this.disableCompression&&this.plugin.settings.compress)}async saveDataURLtoVault(e,t,A){var i;const n=this.scene;let a=`Pasted Image ${window.moment().format("YYYYMMDDHHmmss_SSS")}`;switch(t){case"image/png":default:a+=".png";break;case"image/jpeg":a+=".jpg";break;case"image/svg+xml":a+=".svg";break;case"image/gif":a+=".gif"}const r=(await getAttachmentsFolderAndFilePath(this.app,this.file.path,a)).filepath,s=await getBinaryFileFromDataURL(e);if(!s)return null;const o=await this.app.vault.createBinary(r,s),l=new EmbeddedFile(this.plugin,this.file.path,r);return l.setImage(e,t,{height:0,width:0},"dark"===(null===(i=n.appState)||void 0===i?void 0:i.theme),"image/svg+xml"===t),this.setFile(A,l),o}async syncFiles(){let e=!1;const t=this.scene,A=t.elements.filter((e=>"image"===e.type)).map((e=>e.fileId));if(this.files.forEach(((t,i)=>{A.contains(i)||(this.files.delete(i),e=!0)})),this.equations.forEach(((t,i)=>{A.contains(i)||(this.equations.delete(i),e=!0)})),!t.files||0===Object.keys(t.files).length)return!1;const i=new Set;A.forEach((A=>{if(i.has(A)){const n=this.getFile(A),a=this.getEquation(A);if(n&&(n.isHyperlink||n.file&&("md"!==n.file.extension||this.plugin.isExcalidrawFile(n.file))))return;const r=fileid();t.elements.filter((e=>e.fileId===A))[0].fileId=r,e=!0,i.add(r),n&&this.setFile(r,new EmbeddedFile(this.plugin,this.file.path,n.linkParts.original)),a&&this.setEquation(r,{latex:a.latex,isLoaded:!1})}i.add(A)}));for(const A of Object.keys(t.files))this.hasFile(A)||this.hasEquation(A)||(e=!0,await this.saveDataURLtoVault(t.files[A].dataURL,t.files[A].mimeType,A));return e}async syncElements(e,t){this.scene=e;let A=!1;return this.compatibilityMode||(A=await this.syncFiles(),this.scene.files={}),this.updateElementLinksFromScene(),A=A||this.setLinkPrefix()||this.setUrlPrefix()||this.setShowLinkBrackets()||this.findNewElementLinksInScene(),await this.updateTextElementsFromScene(),A||this.findNewTextElementsInScene(t)}async updateScene(e){this.scene=JSON_parse(e),this.updateElementLinksFromScene();const t=this.setLinkPrefix()||this.setUrlPrefix()||this.setShowLinkBrackets()||this.setembeddableThemePreference()||this.findNewElementLinksInScene();return await this.updateTextElementsFromScene(),!(!t&&!this.findNewTextElementsInScene()||(await this.updateSceneTextElements(),0))}getRawText(e){var t;return null===(t=this.textElements.get(e))||void 0===t?void 0:t.raw}getParsedText(e){const t=this.textElements.get(e);return t?[wrap(t.parsed,t.wrapAt),t.parsed,null]:[null,null,null]}setTextElement(e,t,A,i){const n=estimateMaxLineLen(t,A),[a,r]=this.quickParse(A);return a?(this.textElements.set(e,{raw:A,parsed:a,wrapAt:n}),[wrap(a,n),a,r]):(this.parse(A).then((t=>{const a=t.parsed;this.textElements.set(e,{raw:A,parsed:a,wrapAt:n}),a&&i(wrap(a,n),a)})),[null,null,null])}async addTextElement(e,t,A){let i=estimateMaxLineLen(t,A);this.textElements.has(e)&&(i=this.textElements.get(e).wrapAt);const n=await this.parse(A);return this.textElements.set(e,{raw:A,parsed:n.parsed,wrapAt:i}),[wrap(n.parsed,i),n.parsed,n.link]}deleteTextElement(e){this.textElements.delete(e)}getOpenMode(){const e=this.app.metadataCache.getFileCache(this.file);let t="view-mobile"===this.plugin.settings.defaultMode?DEVICE.isPhone?"view":"normal":this.plugin.settings.defaultMode;switch((null==e?void 0:e.frontmatter)&&null!=e.frontmatter["excalidraw-default-mode"]&&(t=e.frontmatter["excalidraw-default-mode"]),t){case"zen":return{viewModeEnabled:!1,zenModeEnabled:!0};case"view":return{viewModeEnabled:!0,zenModeEnabled:!1};default:return{viewModeEnabled:!1,zenModeEnabled:!1}}}getLinkOpacity(){const e=this.app.metadataCache.getFileCache(this.file);let t=this.plugin.settings.linkOpacity;return(null==e?void 0:e.frontmatter)&&null!=e.frontmatter["excalidraw-linkbutton-opacity"]&&(t=e.frontmatter["excalidraw-linkbutton-opacity"]),t}getOnLoadScript(){const e=this.app.metadataCache.getFileCache(this.file);return(null==e?void 0:e.frontmatter)&&null!=e.frontmatter["excalidraw-onload-script"]?e.frontmatter["excalidraw-onload-script"]:null}setLinkPrefix(){const e=this.linkPrefix,t=this.app.metadataCache.getFileCache(this.file);return(null==t?void 0:t.frontmatter)&&null!=t.frontmatter["excalidraw-link-prefix"]?this.linkPrefix=t.frontmatter["excalidraw-link-prefix"]:this.linkPrefix=this.plugin.settings.linkPrefix,e!=this.linkPrefix}setUrlPrefix(){const e=this.urlPrefix,t=this.app.metadataCache.getFileCache(this.file);return(null==t?void 0:t.frontmatter)&&null!=t.frontmatter["excalidraw-url-prefix"]?this.urlPrefix=t.frontmatter["excalidraw-url-prefix"]:this.urlPrefix=this.plugin.settings.urlPrefix,e!=this.urlPrefix}setAutoexportPreferences(){const e=this.app.metadataCache.getFileCache(this.file);if((null==e?void 0:e.frontmatter)&&null!=e.frontmatter["excalidraw-autoexport"])switch(e.frontmatter["excalidraw-autoexport"].toLowerCase()){case"none":this.autoexportPreference=AutoexportPreference.none;break;case"both":this.autoexportPreference=AutoexportPreference.both;break;case"png":this.autoexportPreference=AutoexportPreference.png;break;case"svg":this.autoexportPreference=AutoexportPreference.svg;break;default:this.autoexportPreference=AutoexportPreference.inherit}else this.autoexportPreference=AutoexportPreference.inherit}setembeddableThemePreference(){const e=this.embeddableTheme,t=this.app.metadataCache.getFileCache(this.file);return(null==t?void 0:t.frontmatter)&&null!=t.frontmatter["excalidraw-iframe-theme"]?(this.embeddableTheme=t.frontmatter["excalidraw-iframe-theme"].toLowerCase(),EMBEDDABLE_THEME_FRONTMATTER_VALUES.includes(this.embeddableTheme)||(this.embeddableTheme="default")):this.embeddableTheme=this.plugin.settings.iframeMatchExcalidrawTheme?"auto":"default",e!=this.embeddableTheme}setShowLinkBrackets(){const e=this.showLinkBrackets,t=this.app.metadataCache.getFileCache(this.file);return(null==t?void 0:t.frontmatter)&&null!=t.frontmatter["excalidraw-link-brackets"]?this.showLinkBrackets=0!=t.frontmatter["excalidraw-link-brackets"]:this.showLinkBrackets=this.plugin.settings.showLinkBrackets,e!=this.showLinkBrackets}setFile(e,t){if(!t)return;if(this.files.set(e,t),t.isHyperlink)return void this.plugin.filesMaster.set(e,{isHyperlink:!0,path:t.hyperlink,blockrefData:null,hasSVGwithBitmap:t.isSVGwithBitmap});if(!t.file)return;const A=t.linkParts.original.split("#");this.plugin.filesMaster.set(e,{isHyperlink:!1,path:t.file.path+(t.shouldScale()?"":"|100%"),blockrefData:1===A.length?null:A[1],hasSVGwithBitmap:t.isSVGwithBitmap,colorMapJSON:t.colorMap?JSON.stringify(t.colorMap):null})}getFiles(){return Object.values(this.files)}getFile(e){let t=this.files.get(e);if(t)return t;const A=this.plugin.filesMaster.get(e);return A?(t=new EmbeddedFile(this.plugin,this.file.path,A.blockrefData?A.path+"#"+A.blockrefData:A.path),this.files.set(e,t),t):t}getFileEntries(){return this.files.entries()}deleteFile(e){this.files.delete(e)}hasFile(e){if(this.files.has(e))return!0;if(this.plugin.filesMaster.has(e)){const t=this.plugin.filesMaster.get(e);if(t.isHyperlink)return this.files.set(e,new EmbeddedFile(this.plugin,this.file.path,t.path)),!0;const A=t.path.split("|")[0].split("#")[0];if(!this.app.vault.getAbstractFileByPath(A))return this.plugin.filesMaster.delete(e),!0;const i=t.path.endsWith("100%"),n=new EmbeddedFile(this.plugin,this.file.path,(t.blockrefData?A+"#"+t.blockrefData:A)+(i?"|100%":""),t.colorMapJSON);return this.files.set(e,n),!0}return!1}setEquation(e,t){this.equations.set(e,{latex:t.latex,isLoaded:t.isLoaded}),this.plugin.equationsMaster.set(e,t.latex)}getEquation(e){let t=this.equations.get(e);if(t)return t;const A=this.plugin.equationsMaster.get(e);return A?(this.equations.set(e,{latex:A,isLoaded:!1}),{latex:A,isLoaded:!1}):t}getEquationEntries(){return this.equations.entries()}deleteEquation(e){this.equations.delete(e)}hasEquation(e){return!!this.equations.has(e)||!!this.plugin.equationsMaster.has(e)&&(this.equations.set(e,{latex:this.plugin.equationsMaster.get(e),isLoaded:!1}),!0)}}const getTransclusion=async(e,t,A,i)=>{var n,a,r,s,o,l,c,d,h;if(!e.path)return{contents:e.original.trim(),lineNum:0};if(!(A&&A instanceof obsidian_module.TFile))return{contents:e.original.trim(),lineNum:0};const u=await t.vault.read(A);if(!e.ref)return i?{contents:u.substring(0,i).trim(),lineNum:0}:{contents:u.trim(),lineNum:0};const g=(await t.metadataCache.blockCache.getForFile({isCancelled:()=>!1},A)).blocks.filter((e=>"comment"!=e.node.type));if(!g)return{contents:e.original.trim(),lineNum:0};if(e.isBlockRef){let t=null===(n=g.filter((t=>t.node.id==e.ref))[0])||void 0===n?void 0:n.node;if(!t)return{contents:e.original.trim(),lineNum:0};["blockquote"].includes(t.type)&&(t=t.children[0]);const A=t.position.start.offset,i=t.position.start.line,a=t.position.end.offset;return{contents:u.substring(A,a).replaceAll(/ \^\S*$|^\^\S*$/gm,"").trim(),lineNum:i}}const p=g.filter((e=>0===e.display.search(/^#+\s/)));let m=null,w=0,f=null,E=1;for(let t=0;tE;)e++;return e===p.length&&p[e-1].node.depth>E?{leadingHashes:"#".repeat(E)+" ",contents:u.substring(m).trim(),lineNum:w}:(f=p[e].node.position.start.offset-1,{leadingHashes:"#".repeat(E)+" ",contents:u.substring(m,f).trim(),lineNum:w})}const A=p[t].node.children[0],i=null===(r=null===(a=p[t].node.data)||void 0===a?void 0:a.hProperties)||void 0===r?void 0:r.dataHeading,n=null==A?void 0:A.children;!m&&((null===(s=null==A?void 0:A.value)||void 0===s?void 0:s.replaceAll(REG_BLOCK_REF_CLEAN,""))===e.ref||(null===(o=null==A?void 0:A.title)||void 0===o?void 0:o.replaceAll(REG_BLOCK_REF_CLEAN,""))===e.ref||(null==i?void 0:i.replaceAll(REG_BLOCK_REF_CLEAN,""))===e.ref||n&&(null===(c=null===(l=n[0])||void 0===l?void 0:l.value)||void 0===c?void 0:c.replaceAll(REG_BLOCK_REF_CLEAN,""))===e.ref)&&(m=null===(d=p[t].node.children[0])||void 0===d?void 0:d.position.start.offset,E=p[t].node.depth,w=null===(h=p[t].node.children[0])||void 0===h?void 0:h.position.start.line)}return m?{leadingHashes:"#".repeat(E)+" ",contents:u.substring(m).trim(),lineNum:w}:{contents:e.original.trim(),lineNum:0}};class ScriptEngine{constructor(e){this.plugin=e,this.scriptIconMap={},this.loadScripts(),this.registerEventHandlers()}registerEventHandlers(){const e=e=>{if(!e.endsWith(".svg"))return;const t=app.vault.getAbstractFileByPath(getIMGFilename(e,"md"));t&&t instanceof obsidian_module.TFile&&(this.unloadScript(this.getScriptName(t),t.path),this.loadScript(t))};this.plugin.registerEvent(app.vault.on("delete",(async t=>{t instanceof obsidian_module.TFile&&t.path.startsWith(this.scriptPath)&&(this.unloadScript(this.getScriptName(t),t.path),e(t.path))}))),this.plugin.registerEvent(app.vault.on("create",(async t=>{t instanceof obsidian_module.TFile&&t.path.startsWith(this.scriptPath)&&(this.loadScript(t),e(t.path))}))),this.plugin.registerEvent(app.vault.on("rename",(async(t,A)=>{if(!(t instanceof obsidian_module.TFile))return;const i=A.startsWith(this.scriptPath),n=t.path.startsWith(this.scriptPath);i&&(this.unloadScript(this.getScriptName(A),A),e(A)),n&&(this.loadScript(t),e(t.path))})))}updateScriptPath(){this.scriptPath!==this.plugin.settings.scriptFolderPath&&(this.scriptPath&&this.unloadScripts(),this.loadScripts())}getListofScripts(){if(this.scriptPath=this.plugin.settings.scriptFolderPath,app.vault.getAbstractFileByPath(this.scriptPath))return app.vault.getFiles().filter((e=>e.path.startsWith(this.scriptPath)&&"md"===e.extension));this.scriptPath=null}loadScripts(){var e;null===(e=this.getListofScripts())||void 0===e||e.forEach((e=>this.loadScript(e)))}getScriptName(e){let t="",A="";e instanceof obsidian_module.TFile?(t=e.basename,A=e.path):(t=splitFolderAndFilename(e).basename,A=e);const i=A.split(`${this.scriptPath}/`)[1],n=i.lastIndexOf("/");return n>-1?i.substring(0,n+1)+t:t}async addScriptIconToMap(e,t){const A=getIMGFilename(e,"svg"),i=app.vault.getAbstractFileByPath(A),n=i&&i instanceof obsidian_module.TFile?await app.vault.read(i):null;this.scriptIconMap=Object.assign({},this.scriptIconMap);const a=splitFolderAndFilename(t);this.scriptIconMap[e]={name:a.filename,group:"/"===a.folderpath?"":a.folderpath,svgString:n},this.updateToolPannels()}loadScript(e){if("md"!==e.extension)return;const t=this.getScriptName(e);this.addScriptIconToMap(e.path,t),this.plugin.addCommand({id:t,name:`(Script) ${t}`,checkCallback:A=>{if(A)return Boolean(app.workspace.getActiveViewOfType(ExcalidrawView));const i=app.workspace.getActiveViewOfType(ExcalidrawView);return!!i&&((async()=>{const A=await app.vault.read(e);A&&this.executeScript(i,A,t,e)})(),!0)}})}unloadScripts(){const e=app.vault.getFiles().filter((e=>e.path.startsWith(this.scriptPath)));e.forEach((e=>{this.unloadScript(this.getScriptName(e),e.path)}))}unloadScript(e,t){if(!t.endsWith(".md"))return;delete this.scriptIconMap[t],this.scriptIconMap=Object.assign({},this.scriptIconMap),this.updateToolPannels();const A=`${PLUGIN_ID}:${e}`;app.commands.commands[A]&&delete app.commands.commands[A]}async executeScript(e,t,A,i){if(!e||!t||!A)return;this.plugin.ea.reset(),this.plugin.ea.setView(e),this.plugin.ea.activeScript=A;const n=Object.getPrototypeOf((async()=>{})).constructor;let a=null;return a=await new n("ea","utils",t)(this.plugin.ea,{inputPrompt:(t,A,i,n,a,r,s,o)=>ScriptEngine.inputPrompt(e,this.plugin,app,t,A,i,n,a,r,s,o),suggester:(e,t,A,i)=>ScriptEngine.suggester(app,e,t,A,i),scriptFile:i}),this.plugin.ea.activeScript=null,a}updateToolPannels(){app.workspace.getLeavesOfType("excalidraw").forEach((e=>{var t,A;null===(A=null===(t=e.view.toolsPanelRef)||void 0===t?void 0:t.current)||void 0===A||A.updateScriptIconMap(this.scriptIconMap)}))}static async inputPrompt(e,t,A,i,n,a,r,s,o,l,c){try{return await GenericInputPrompt.Prompt(e,t,A,i,n,a,r,s,o,l,c)}catch(e){return}}static async suggester(e,t,A,i,n){try{return await GenericSuggester.Suggest(e,t,A,i,n)}catch(e){return}}}var t$c={d:(e,t)=>{for(var A in t)t$c.o(t,A)&&!t$c.o(e,A)&&Object.defineProperty(e,A,{enumerable:!0,get:t[A]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t)},r$e={};t$c.d(r$e,{QA:()=>w$1,ZP:()=>j$1,qt:()=>x$1,MX:()=>$});const e$d={red:"hsl(0, 100%, 50%)",orange:"hsl(30, 100%, 50%)",yellow:"hsl(60, 100%, 50%)","lime green":"hsl(90, 100%, 50%)",green:"hsl(120, 100%, 50%)","blue green":"hsl(150, 100%, 50%)",cyan:"hsl(180, 100%, 50%)","sky blue":"hsl(210, 100%, 50%)",blue:"hsl(240, 100%, 50%)",purple:"hsl(270, 100%, 50%)",magenta:"hsl(300, 100%, 50%)",pink:"hsl(330, 100%, 50%)"};function s$a(e,t,A){return Math.max(e,Math.min(t,A))}function n$c(e,t){return+e.toFixed(t>=0?t:0)}function a$c(e){const t=e%360;return t<0?t+360:t}function i$a(e){return void 0!==e?s$a(0,e,1):1}function o$b(e){return Math.floor(Math.random()*e)}function h$4(e){var t;const{Cmin:A,Cmax:i,H:n,delta:a}=function(e){const[t,A,i]=Object.values(e).map((e=>e/255)),n=Math.max(t,A,i),a=Math.min(t,A,i),r=n-a;return{Cmin:a,Cmax:n,H:0===r?0:n===t?(A-i)/r%6:n===A?(i-t)/r+2:(t-A)/r+4,delta:r}}(e),r=(i+A)/2,s=0===a?0:a/(1-Math.abs(2*r-1));return{h:a$c(60*n),s:100*s,l:100*r,a:null!==(t=e.a)&&void 0!==t?t:1}}function u$8(e){const{h:t,s:A,l:i,a:n}=e,a=i/100,r=A/100,s=(1-Math.abs(2*a-1))*r,o=s*(1-Math.abs(t/60%2-1)),l=a-s/2,c=t<60||300<=t&&t<360?s:120<=t&&t<240?0:o,d=240<=t&&t<360?0:60<=t&&t<180?s:o,h=t<120?0:180<=t&&t<300?s:o,[u,g,p]=[c,d,h].map((e=>255*(e+l)));return{r:u,g:g,b:p,a:null!=n?n:1}}function l$5(e){const[t,A,i,n]=Object.values(e).map((e=>parseInt(e,16)));return{r:t,g:A,b:i,a:n?n/255:1}}const c$a=/^#?([\da-f])([\da-f])([\da-f])([\da-f])?$|^#?([\da-f]{2})([\da-f]{2})([\da-f]{2})?([\da-f]{2})?$/gi,f$3=/hsla?\s*\(\s*([+-]?\d*\.?\d+%?)\s*,?\s*(\d*\.?\d+%?)\s*,?\s*(\d*\.?\d+%?)\s*,?\s*\/?\s*?(\d*\.?\d+%?)?\s*\)/gi;function d$2({h:e,s:t,l:A,a:i}){return[u$8({h:a$c(e),s:s$a(0,t,100),l:s$a(0,A,100),a:i$a(i)}),"hsl"]}const g$2=/rgba?\s*\(\s*(\d*\.?\d+%?)\s*,?\s*(\d*\.?\d+%?)\s*,?\s*(\d*\.?\d+%?)\s*,?\s*\/?\s*?(\d*\.?\d+%?)?\s*\)/gi;function b$5({r:e,g:t,b:A,a:i}){return[{r:s$a(0,e,255),g:s$a(0,t,255),b:s$a(0,A,255),a:i$a(i)},"rgb"]}var p$3,v$2,m$1=function(e,t,A,i,n){if("m"===i)throw new TypeError("Private method is not writable");if("a"===i&&!n)throw new TypeError("Private accessor was defined without a setter");if("function"==typeof t?e!==t||!n:!t.has(e))throw new TypeError("Cannot write private member to an object whose class did not declare it");return"a"===i?n.call(e,A):n?n.value=A:t.set(e,A),A},y$1=function(e,t,A,i){if("a"===A&&!i)throw new TypeError("Private accessor was defined without a getter");if("function"==typeof t?e!==t||!i:!t.has(e))throw new TypeError("Cannot read private member from an object whose class did not declare it");return"m"===A?i:"a"===A?i.call(e):i?i.value:t.get(e)};class w$1{constructor(e){var t,A;p$3.set(this,{r:0,g:0,b:0,a:1}),v$2.set(this,"rgb");const i=w$1.Parsers.map((t=>t(e))).find((e=>"invalid"!==e[1]));i?(t=this,A=this,[{set value(e){m$1(t,p$3,e,"f")}}.value,{set value(e){m$1(A,v$2,e,"f")}}.value]=i):m$1(this,v$2,"invalid","f")}get red(){return y$1(this,p$3,"f").r}get blue(){return y$1(this,p$3,"f").b}get green(){return y$1(this,p$3,"f").g}get alpha(){return y$1(this,p$3,"f").a}get hue(){return h$4(y$1(this,p$3,"f")).h}get saturation(){return h$4(y$1(this,p$3,"f")).s}get lightness(){return h$4(y$1(this,p$3,"f")).l}get format(){return y$1(this,v$2,"f")}isValid(){return"invalid"!==y$1(this,v$2,"f")}rgba(){return y$1(this,p$3,"f")}hsla(){return h$4(y$1(this,p$3,"f"))}hexa({round:e=!1}={}){return function(e,t=!1){let{r:A,g:i,b:n,a:a}=e;a&&(a*=255),t&&([A,i,n,a]=[A,i,n,a].map((e=>e&&Math.round(e))));const[r,s,o,l]=[A,i,n,null!=a?a:255].map((e=>e.toString(16).padStart(2,"0").toUpperCase()));return{r:r,g:s,b:o,a:l}}(y$1(this,p$3,"f"),e)}stringRGB({alpha:e=!0,precision:t=[0,0,0,1]}={}){const[A,i,n,a]=Object.values(y$1(this,p$3,"f")).map(((e,A)=>n$c(e,t[A])));return e?`rgba(${A}, ${i}, ${n}, ${a})`:`rgb(${A}, ${i}, ${n})`}stringHEX({alpha:e=!0}={}){const[t,A,i,n]=Object.values(this.hexa({round:!0}));return`#${t}${A}${i}${e?n:""}`}stringHSL({alpha:e=!0,precision:t=[0,0,0,1]}={}){const[A,i,n,a]=Object.values(this.hsla()).map(((e,A)=>n$c(e,t[A])));return e?`hsla(${A}, ${i}%, ${n}%, ${a})`:`hsl(${A}, ${i}%, ${n}%)`}hueTo(e){var t;const{h:A,s:i,l:n,a:a}=this.hsla(),r="number"==typeof e?a$c(e):Number(null!==(t=e$d[e].match(/\d{1,3}/))&&void 0!==t?t:A);return m$1(this,p$3,u$8({h:r,s:i,l:n,a:a}),"f"),this}hueBy(e){const{h:t,s:A,l:i,a:n}=this.hsla();return m$1(this,p$3,u$8({h:a$c(t+e),s:A,l:i,a:n}),"f"),this}saturationTo(e){const{h:t,l:A,a:i}=this.hsla();return m$1(this,p$3,u$8({h:t,s:s$a(0,e,100),l:A,a:i}),"f"),this}saturateBy(e){const{h:t,s:A,l:i,a:n}=this.hsla();return m$1(this,p$3,u$8({h:t,s:s$a(0,A+e,100),l:i,a:n}),"f"),this}desaturateBy(e){return this.saturateBy(-1*e)}lightnessTo(e){const{h:t,s:A,a:i}=this.hsla();return m$1(this,p$3,u$8({h:t,s:A,l:s$a(0,e,100),a:i}),"f"),this}lighterBy(e){const{h:t,s:A,l:i,a:n}=this.hsla();return m$1(this,p$3,u$8({h:t,s:A,l:s$a(0,i+e,100),a:n}),"f"),this}darkerBy(e){return this.lighterBy(-1*e)}alphaTo(e){return m$1(this,p$3,Object.assign(Object.assign({},y$1(this,p$3,"f")),{a:s$a(0,e,1)}),"f"),this}alphaBy(e){return m$1(this,p$3,Object.assign(Object.assign({},y$1(this,p$3,"f")),{a:s$a(0,y$1(this,p$3,"f").a+e,1)}),"f"),this}invert({alpha:e=!1}={}){const{r:t,g:A,b:i,a:n}=y$1(this,p$3,"f");return m$1(this,p$3,{r:255-t,g:255-A,b:255-i,a:e?1-n:n},"f"),this}grayscale(){return this.desaturateBy(100)}rotate(e){return this.hueBy(e)}}function $(){return new w$1({r:o$b(255),g:o$b(255),b:o$b(255),a:Math.random()})}function x$1(e){(e=e.filter(((e,t,A)=>A.indexOf(e)===t))).forEach((e=>e(w$1)))}p$3=new WeakMap,v$2=new WeakMap,w$1.Parsers=[function(e){if("object"===e.constructor.name.toLowerCase()&&function(e){const{r:t,g:A,b:i}=e;return void 0!==t&&void 0!==A&&void 0!==i&&"number"==typeof t}(e))return b$5(e);if("string"==typeof e){g$2.lastIndex=0;const t=g$2.exec(e);if(t){const[e,A,i,n]=t.filter((e=>void 0!==e)).slice(1).map(((e,t)=>e.includes("%")?+e.slice(0,-1)*(t<3?2.55:.01):+e));return b$5({r:e,g:A,b:i,a:n})}}return[{r:0,g:0,b:0,a:1},"invalid"]},function(e){if("object"===e.constructor.name.toLowerCase()&&function(e){const{r:t,g:A,b:i}=e;return void 0!==t&&void 0!==A&&void 0!==i&&"string"==typeof t}(e))return[l$5(e),"hex"];if("string"==typeof e){c$a.lastIndex=0;const t=c$a.exec(e);if(t){const[e,A,i,n]=t.filter((e=>void 0!==e)).slice(1).map((e=>1===e.length?e.repeat(2):e));return[l$5({r:e,g:A,b:i,a:null!=n?n:"FF"}),"hex"]}}return[{r:0,g:0,b:0,a:1},"invalid"]},function(e){if("object"===e.constructor.name.toLowerCase()&&function(e){const{h:t,s:A,l:i}=e;return void 0!==t&&void 0!==A&&void 0!==i}(e))return d$2(e);if("string"==typeof e){f$3.lastIndex=0;const t=f$3.exec(e);if(t){const[e,A,i,n]=t.filter((e=>void 0!==e)).slice(1).map(((e,t)=>e.includes("%")?+e.slice(0,-1)*(0===t?3.59:t<3?1:.01):+e));return d$2({h:e,s:A,l:i,a:n})}}return[{r:0,g:0,b:0,a:1},"invalid"]}];const j$1=e=>new w$1(e);r$e.QA;var O$1=r$e.ZP,B=r$e.qt;r$e.MX;var e$c={d:(e,t)=>{for(var A in t)e$c.o(t,A)&&!e$c.o(e,A)&&Object.defineProperty(e,A,{enumerable:!0,get:t[A]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t)},a$b={};function t$b(e){const t=e%360;return t<0?t+360:t}e$c.d(a$b,{Z:()=>n$b});const n$b=e=>{e.prototype.harmony=function({type:t="analogous",effect:A="tones",amount:i=5}={}){const{h:n,s:a,l:r,a:s}=this.hsla();switch("monochromatic"===t&&(o=i,i=Math.max(2,Math.min(o,10))),t){case"analogous":return[-30,0,30].map((t=>new e({h:t$b(n+t),s:a,l:r,a:s})));case"complementary":return[0,180].map((t=>new e({h:t$b(n+t),s:a,l:r,a:s})));case"split-complementary":return[0,150,210].map((t=>new e({h:t$b(n+t),s:a,l:r,a:s})));case"double-split-complementary":return[-30,0,30,150,210].map((t=>new e({h:t$b(n+t),s:a,l:r,a:s})));case"triad":return[0,120,240].map((t=>new e({h:t$b(n+t),s:a,l:r,a:s})));case"rectangle":return[0,60,180,240].map((t=>new e({h:t$b(n+t),s:a,l:r,a:s})));case"square":return[0,90,180,270].map((t=>new e({h:t$b(n+t),s:a,l:r,a:s})));case"monochromatic":{const t="tones"===A?a:r;let o=("tints"===A?100-t:t)/i;o="tints"===A?o:-1*o;const l=[t];for(let e=0;enew e({h:n,s:t,l:r,a:s}))):l.map((t=>new e({h:n,s:a,l:t,a:s})))}}var o}};var r$d=a$b.Z,a$a={d:(e,t)=>{for(var A in t)a$a.o(t,A)&&!a$a.o(e,A)&&Object.defineProperty(e,A,{enumerable:!0,get:t[A]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t)},t$a={};a$a.d(t$a,{Z:()=>k});const e$b=6/29,n$a=Math.pow(e$b,3),c$9=Math.pow(29/3,3),r$c={x:.96422,y:1,z:.82521};function u$7(e,t){return[e[0][0]*t[0]+e[0][1]*t[1]+e[0][2]*t[2],e[1][0]*t[0]+e[1][1]*t[1]+e[1][2]*t[2],e[2][0]*t[0]+e[2][1]*t[1]+e[2][2]*t[2]]}function s$9(e,t,A){return Math.max(e,Math.min(t,A))}function o$a(e){const t=e%360;return t<0?t+360:t}function l$4(e){const[t,A,i]=Object.values(e).map((e=>e/255)),n=Math.max(t,A,i),a=Math.min(t,A,i),r=n-a;return{Cmin:a,Cmax:n,H:0===r?0:n===t?(A-i)/r%6:n===A?(i-t)/r+2:(t-A)/r+4,delta:r}}function b$4(e){var t;const{Cmin:A,Cmax:i,H:n,delta:a}=l$4(e),r=(i+A)/2,s=0===a?0:a/(1-Math.abs(2*r-1));return{h:o$a(60*n),s:100*s,l:100*r,a:null!==(t=e.a)&&void 0!==t?t:1}}function h$3(e){var t;const{Cmax:A,H:i,delta:n}=l$4(e),a=0===n?0:n/A;return{h:o$a(60*i),s:100*a,v:100*A,a:null!==(t=e.a)&&void 0!==t?t:1}}function v$1(e){const{h:t,a:A}=b$4(e),{r:i,g:n,b:a}=e;return{h:t,w:Math.min(i,n,a)/2.55,b:100*(1-Math.max(i,n,a)/255),a:A}}function i$9(e){const[t,A,i]=u$7([[.41239079926595934,.357584339383878,.1804807884018343],[.21263900587151027,.715168678767756,.07219231536073371],[.01933081871559182,.11919477979462598,.9505321522496607]],Object.values(e).map((e=>{return 100*(t=e,(t/=255)<.04045?t/12.92:Math.pow((t+.055)/1.055,2.4));var t})));return function(e){const[t,A,i]=u$7([[1.0479298208405488,.022946793341019088,-.05019222954313557],[.029627815688159344,.990434484573249,-.01707382502938514],[-.009243058152591178,.015055144896577895,.7518742899580008]],Object.values(e));return{x:t,y:A,z:i,a:e.a}}({x:t,y:A,z:i,a:e.a})}function m(e){const t=Object.values(i$9(e)).map(((e,t)=>e/(100*Object.values(r$c)[t]))).map((e=>e>n$a?Math.cbrt(e):(c$9*e+16)/116));return{l:116*t[1]-16,a:500*(t[0]-t[1]),b:200*(t[1]-t[2]),alpha:e.a}}function p$2(e){const{l:t,a:A,b:i}=m(e),n=180*Math.atan2(i,A)/Math.PI;return{l:t,c:Math.sqrt(Math.pow(A,2)+Math.pow(i,2)),h:o$a(n),a:e.a}}function f$2(e){const[t,A,i]=Object.values(i$9(e)).map((e=>e/100)),n=A/r$c.y,a=t&&A&&i?t+15*A+3*i:19,r=4*t/a,s=9*A/a,o=r$c.x+15*r$c.y+3*r$c.z,l=4*r$c.x/o,c=9*r$c.y/o;let d=n>n$a?116*Math.cbrt(n)-16:c$9*n,h=13*d*(r-l),u=13*d*(s-c);return d===Number(-0)&&(d=0),h===Number(-0)&&(h=0),u===Number(-0)&&(u=0),{l:d,u:h,v:u,a:e.a}}function M(e){const{x:t,y:A,z:i}=i$9(e),[n,a,r]=u$7([[2/3,0,0],[0,1,0],[-.5,1.5,.5]],[t,A,i]);return{u:n,v:a,w:r,a:e.a}}function w(e){let{r:t,g:A,b:i}=e;const n=Math.min(t,A,i);[t,A,i]=[t,A,i].map((e=>e-n));const a=Math.max(t,A,i);let r=Math.min(t,A);t-=r,A-=r,i&&A&&(i/=2,A/=2),r+=A,i+=A;const s=Math.max(t,r,i);if(s){const e=a/s;[t,r,i]=[t,r,i].map((t=>t*e))}return[t,r,i]=[t,r,i].map((e=>e+n)),{r:t,y:r,b:i,a:e.a}}function O(e){const{r:t,g:A,b:i,a:n}=e,a=1-Math.max(t,A,i)/255,[r,s,o]=1===a?[0,0,0]:[t,A,i].map((e=>100*(1-e/255-a)/(1-a)));return{c:r,m:s,y:o,k:100*a,a:n}}function j(e){const{h:t,s:A,v:i,a:n}=e,a=i/100,r=a*(A/100),s=r*(1-Math.abs(t/60%2-1)),o=a-r,l=t<60||300<=t&&t<360?r:120<=t&&t<240?0:s,c=240<=t&&t<360?0:60<=t&&t<180?r:s,d=t<120?0:180<=t&&t<300?r:s,[h,u,g]=[l,c,d].map((e=>255*(e+o)));return{r:h,g:u,b:g,a:null!=n?n:1}}function x(e){const[t,A,i]=Object.values(function(e){const[t,A,i]=u$7([[.9554734527042182,-.023098536874261423,.0632593086610217],[-.028369706963208136,1.0099954580058226,.021041398966943008],[.012314001688319899,-.020507696433477912,1.3303659366080753]],Object.values(e));return{x:t,y:A,z:i,a:e.a}}(e)).map((e=>e/100)),[n,a,r]=u$7([[3.2409699419045226,-1.537383177570094,-.4986107602930034],[-.9692436362808796,1.8759675015077202,.04155505740717559],[.05563007969699366,-.20397695888897652,1.0569715142428786]],[t,A,i]).map((e=>{return s$9(0,255*((t=e)>.0031308?1.055*Math.pow(t,1/2.4)-.055:12.92*t),255);var t}));return{r:n,g:a,b:r,a:e.a}}function y(e){const{l:t,a:A,b:i}=e,n=(t+16)/116,a=n+A/500,r=n-i/200,s=Object.values(r$c),[o,l,c]=[a,n,r].map(((e,t)=>(e>e$b?Math.pow(e,3):3*Math.pow(e$b,2)*(e-4/29))*s[t]*100));return x({x:o,y:l,z:c,a:e.alpha})}const k=e=>{e.prototype.mix=function({color:t="#fff",ratio:A=.5,colorspace:i="luv"}={}){const n=this.rgba(),a=(t instanceof e?t:new e(t)).rgba();let r,s;switch(A=s$9(0,A,1),i){case"hsl":r=Object.values(b$4(n)),s=Object.values(b$4(a));break;case"hsv":r=Object.values(h$3(n)),s=Object.values(h$3(a));break;case"hwb":r=Object.values(v$1(n)),s=Object.values(v$1(a));break;case"lab":r=Object.values(m(n)),s=Object.values(m(a));break;case"lch":r=Object.values(p$2(n)),s=Object.values(p$2(a));break;case"luv":r=Object.values(f$2(n)),s=Object.values(f$2(a));break;case"ryb":r=Object.values(w(n)),s=Object.values(w(a));break;case"uvw":r=Object.values(M(n)),s=Object.values(M(a));break;case"xyz":r=Object.values(i$9(n)),s=Object.values(i$9(a));break;case"cmyk":r=Object.values(O(n)),s=Object.values(O(a));break;default:r=Object.values(n),s=Object.values(a)}const[o,l,c,d,h]=r.map(((e,t)=>r[t]*(1-A)+s[t]*A));switch(i){case"hsl":return new e(function(e){const{h:t,s:A,l:i,a:n}=e,a=i/100,r=A/100,s=(1-Math.abs(2*a-1))*r,o=s*(1-Math.abs(t/60%2-1)),l=a-s/2,c=t<60||300<=t&&t<360?s:120<=t&&t<240?0:o,d=240<=t&&t<360?0:60<=t&&t<180?s:o,h=t<120?0:180<=t&&t<300?s:o,[u,g,p]=[c,d,h].map((e=>255*(e+l)));return{r:u,g:g,b:p,a:null!=n?n:1}}({h:o,s:l,l:c,a:d}));case"hsv":return new e(j({h:o,s:l,v:c,a:d}));case"hwb":return new e(function(e){const{h:t,b:A,w:i,a:n}=e;return j({h:t,s:100===A?0:100-i/(100-A)*100,v:100-A,a:n})}({h:o,w:l,b:c,a:d}));case"lab":return new e(y({l:o,a:l,b:c,alpha:d}));case"lch":return new e(function(e){const{l:t,c:A,h:i}=e;return y({l:t,a:A*Math.cos(i*Math.PI/180),b:A*Math.sin(i*Math.PI/180),alpha:e.a})}({l:o,c:l,h:c,a:d}));case"luv":return new e(function(e){const{l:t,u:A,v:i}=e,n=t>c$9*n$a?Math.pow((t+16)/116,3):t/c$9,a=r$c.x+15*r$c.y+3*r$c.z,r=(52*t/(A&&t?A+13*t*(4*r$c.x/a):1)-1)/3,s=-5*n,o=n*(39*t/(i&&t?i+13*t*(9*r$c.y/a):1)-5),l=r===-1/3?o-s:(o-s)/(r- -1/3);return x({x:100*l,y:100*n,z:100*(r*l+s),a:e.a})}({l:o,u:l,v:c,a:d}));case"ryb":return new e(function(e){let{r:t,y:A,b:i}=e;const n=Math.min(t,A,i);[t,A,i]=[t,A,i].map((e=>e-n));const a=Math.max(t,A,i);let r=Math.min(A,i);A-=r,i-=r,i&&r&&(i*=2,r*=2),t+=A,r+=A;const s=Math.max(t,r,i);if(s){const e=a/s;[t,r,i]=[t,r,i].map((t=>t*e))}return[t,r,i]=[t,r,i].map((e=>e+n)),{r:t,g:r,b:i,a:e.a}}({r:o,y:l,b:c,a:d}));case"uvw":return new e(function(e){const{u:t,v:A,w:i}=e,[n,a,r]=u$7([[1.5,0,0],[0,1,0],[1.5,-3,2]],[t,A,i]);return x({x:n,y:a,z:r,a:e.a})}({u:o,v:l,w:c,a:d}));case"xyz":return new e(x({x:o,y:l,z:c,a:d}));case"cmyk":return new e(function(e){const{c:t,m:A,y:i,k:n,a:a}=e,[r,s,o]=[t,A,i].map((e=>255*(1-e/100)*(1-n/100)));return{r:r,g:s,b:o,a:a}}({c:o,m:l,y:c,k:d,a:h}));default:return new e({r:o,g:l,b:c,a:d})}}};var z=t$a.Z,r$b={d:(e,t)=>{for(var A in t)r$b.o(t,A)&&!r$b.o(e,A)&&Object.defineProperty(e,A,{enumerable:!0,get:t[A]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t)},b$3={};r$b.d(b$3,{Z:()=>n$9});const g$1=["rgb(0,0,0)","rgb(0,0,51)","rgb(0,0,102)","rgb(0,0,153)","rgb(0,0,204)","rgb(0,0,255)","rgb(0,51,0)","rgb(0,51,51)","rgb(0,51,102)","rgb(0,51,153)","rgb(0,51,204)","rgb(0,51,255)","rgb(0,102,0)","rgb(0,102,51)","rgb(0,102,102)","rgb(0,102,153)","rgb(0,102,204)","rgb(0,102,255)","rgb(0,153,0)","rgb(0,153,51)","rgb(0,153,102)","rgb(0,153,153)","rgb(0,153,204)","rgb(0,153,255)","rgb(0,204,0)","rgb(0,204,51)","rgb(0,204,102)","rgb(0,204,153)","rgb(0,204,204)","rgb(0,204,255)","rgb(0,255,0)","rgb(0,255,51)","rgb(0,255,102)","rgb(0,255,153)","rgb(0,255,204)","rgb(0,255,255)","rgb(51,0,0)","rgb(51,0,51)","rgb(51,0,102)","rgb(51,0,153)","rgb(51,0,204)","rgb(51,0,255)","rgb(51,51,0)","rgb(51,51,51)","rgb(51,51,102)","rgb(51,51,153)","rgb(51,51,204)","rgb(51,51,255)","rgb(51,102,0)","rgb(51,102,51)","rgb(51,102,102)","rgb(51,102,153)","rgb(51,102,204)","rgb(51,102,255)","rgb(51,153,0)","rgb(51,153,51)","rgb(51,153,102)","rgb(51,153,153)","rgb(51,153,204)","rgb(51,153,255)","rgb(51,204,0)","rgb(51,204,51)","rgb(51,204,102)","rgb(51,204,153)","rgb(51,204,204)","rgb(51,204,255)","rgb(51,255,0)","rgb(51,255,51)","rgb(51,255,102)","rgb(51,255,153)","rgb(51,255,204)","rgb(51,255,255)","rgb(102,0,0)","rgb(102,0,51)","rgb(102,0,102)","rgb(102,0,153)","rgb(102,0,204)","rgb(102,0,255)","rgb(102,51,0)","rgb(102,51,51)","rgb(102,51,102)","rgb(102,51,153)","rgb(102,51,204)","rgb(102,51,255)","rgb(102,102,0)","rgb(102,102,51)","rgb(102,102,102)","rgb(102,102,153)","rgb(102,102,204)","rgb(102,102,255)","rgb(102,153,0)","rgb(102,153,51)","rgb(102,153,102)","rgb(102,153,153)","rgb(102,153,204)","rgb(102,153,255)","rgb(102,204,0)","rgb(102,204,51)","rgb(102,204,102)","rgb(102,204,153)","rgb(102,204,204)","rgb(102,204,255)","rgb(102,255,0)","rgb(102,255,51)","rgb(102,255,102)","rgb(102,255,153)","rgb(102,255,204)","rgb(102,255,255)","rgb(153,0,0)","rgb(153,0,51)","rgb(153,0,102)","rgb(153,0,153)","rgb(153,0,204)","rgb(153,0,255)","rgb(153,51,0)","rgb(153,51,51)","rgb(153,51,102)","rgb(153,51,153)","rgb(153,51,204)","rgb(153,51,255)","rgb(153,102,0)","rgb(153,102,51)","rgb(153,102,102)","rgb(153,102,153)","rgb(153,102,204)","rgb(153,102,255)","rgb(153,153,0)","rgb(153,153,51)","rgb(153,153,102)","rgb(153,153,153)","rgb(153,153,204)","rgb(153,153,255)","rgb(153,204,0)","rgb(153,204,51)","rgb(153,204,102)","rgb(153,204,153)","rgb(153,204,204)","rgb(153,204,255)","rgb(153,255,0)","rgb(153,255,51)","rgb(153,255,102)","rgb(153,255,153)","rgb(153,255,204)","rgb(153,255,255)","rgb(204,0,0)","rgb(204,0,51)","rgb(204,0,102)","rgb(204,0,153)","rgb(204,0,204)","rgb(204,0,255)","rgb(204,51,0)","rgb(204,51,51)","rgb(204,51,102)","rgb(204,51,153)","rgb(204,51,204)","rgb(204,51,255)","rgb(204,102,0)","rgb(204,102,51)","rgb(204,102,102)","rgb(204,102,153)","rgb(204,102,204)","rgb(204,102,255)","rgb(204,153,0)","rgb(204,153,51)","rgb(204,153,102)","rgb(204,153,153)","rgb(204,153,204)","rgb(204,153,255)","rgb(204,204,0)","rgb(204,204,51)","rgb(204,204,102)","rgb(204,204,153)","rgb(204,204,204)","rgb(204,204,255)","rgb(204,255,0)","rgb(204,255,51)","rgb(204,255,102)","rgb(204,255,153)","rgb(204,255,204)","rgb(204,255,255)","rgb(255,0,0)","rgb(255,0,51)","rgb(255,0,102)","rgb(255,0,153)","rgb(255,0,204)","rgb(255,0,255)","rgb(255,51,0)","rgb(255,51,51)","rgb(255,51,102)","rgb(255,51,153)","rgb(255,51,204)","rgb(255,51,255)","rgb(255,102,0)","rgb(255,102,51)","rgb(255,102,102)","rgb(255,102,153)","rgb(255,102,204)","rgb(255,102,255)","rgb(255,153,0)","rgb(255,153,51)","rgb(255,153,102)","rgb(255,153,153)","rgb(255,153,204)","rgb(255,153,255)","rgb(255,204,0)","rgb(255,204,51)","rgb(255,204,102)","rgb(255,204,153)","rgb(255,204,204)","rgb(255,204,255)","rgb(255,255,0)","rgb(255,255,51)","rgb(255,255,102)","rgb(255,255,153)","rgb(255,255,204)","rgb(255,255,255)"];function t$9(e){return(e/=255)<.04045?e/12.92:Math.pow((e+.055)/1.055,2.4)}function o$9(e,t=[0,0,0,1]){var A,i;return null!==(i=null===(A=e.match(/\d{1,3}/g))||void 0===A?void 0:A.map((e=>+e)))&&void 0!==i?i:t}const n$9=e=>{e.prototype.brightness=function({precision:e=4,percentage:t=!1}={}){const{r:A,g:i,b:n}=this.rgba(),a=+((.299*A+.587*i+.114*n)/255).toFixed(e);return t?100*a:a},e.prototype.luminance=function({precision:e=4,percentage:t=!1}={}){const{r:A,g:i,b:n}=this.rgba(),a=+(.2126*t$9(A)+.7152*t$9(i)+.0722*t$9(n)).toFixed(e);return t?100*a:a},e.prototype.contrast=function({bgColor:t="#fff",precision:A=4,ratio:i=!1}={}){const n=this.luminance(),a=(t instanceof e?t:new e(t)).luminance(),r=((Math.max(n,a)+.05)/(Math.min(n,a)+.05)).toFixed(A);return i?r+":1":+r},e.prototype.readableOn=function({bgColor:e="#fff",size:t="body",level:A="minimum"}={}){const i=this.contrast({bgColor:e});return"body"===t&&"enhanced"===A?i>=7:"large"===t&&"minimum"===A?i>=3:i>=4.5},e.prototype.equalTo=function(t="#fff"){const A=Object.values(this.rgba()),i=Object.values((t instanceof e?t:new e(t)).rgba());return A.toString()===i.toString()},e.prototype.isLight=function(){return this.brightness()>=.5},e.prototype.isDark=function(){return!this.isLight()},e.prototype.isCool=function(){const{h:e}=this.hsla();return 75<=e&&e<255},e.prototype.isWarm=function(){return!this.isCool()},e.prototype.isTinted=function(){return this.hsla().l>50},e.prototype.isShaded=function(){return this.hsla().l<50},e.prototype.isToned=function(){return this.hsla().s<100},e.prototype.isPureHue=function({reason:e=!0}={}){return this.isTinted()?!!e&&{pure:!1,reason:"tinted"}:this.isShaded()?!!e&&{pure:!1,reason:"shaded"}:this.isToned()?!!e&&{pure:!1,reason:"toned"}:!e||{pure:!0,reason:"N/A"}},e.prototype.closestCool=function(){const{h:e}=this.hsla();return this.isCool()?this:this.hueTo(e<75?75:254)},e.prototype.closestWarm=function(){const{h:e}=this.hsla();return this.isWarm()?this:this.hueTo(e<165?74:255)},e.prototype.closestPureHue=function(){const{h:t,a:A}=this.hsla(),{r:i,g:n,b:a,a:r}=function(e){const{h:t,s:A,l:i,a:n}=e,a=i/100,r=A/100,s=(1-Math.abs(2*a-1))*r,o=s*(1-Math.abs(t/60%2-1)),l=a-s/2,c=t<60||300<=t&&t<360?s:120<=t&&t<240?0:o,d=240<=t&&t<360?0:60<=t&&t<180?s:o,h=t<120?0:180<=t&&t<300?s:o,[u,g,p]=[c,d,h].map((e=>255*(e+l)));return{r:u,g:g,b:p,a:null!=n?n:1}}({h:t,s:100,l:50,a:A});return new e({r:i,g:n,b:a,a:r})},e.prototype.closestWebSafe=function(){const{r:t,g:A,b:i,a:n}=this.rgba();let[a,r,s]=new Array(3).fill(0),o=Number.POSITIVE_INFINITY,l={r:t,g:A,b:i,a:n};for(let e=0;e{for(var A in t)r$a.o(t,A)&&!r$a.o(e,A)&&Object.defineProperty(e,A,{enumerable:!0,get:t[A]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t)},g={};r$a.d(g,{Z:()=>a$9});const e$9={maroon:"rgb(128,0,0)","dark red":"rgb(139,0,0)",brown:"rgb(165,42,42)",firebrick:"rgb(178,34,34)",crimson:"rgb(220,20,60)",red:"rgb(255,0,0)",tomato:"rgb(255,99,71)",coral:"rgb(255,127,80)","indian red":"rgb(205,92,92)","light coral":"rgb(240,128,128)","dark salmon":"rgb(233,150,122)",salmon:"rgb(250,128,114)","light salmon":"rgb(255,160,122)","orange red":"rgb(255,69,0)","dark orange":"rgb(255,140,0)",orange:"rgb(255,165,0)",gold:"rgb(255,215,0)","dark golden rod":"rgb(184,134,11)","golden rod":"rgb(218,165,32)","pale golden rod":"rgb(238,232,170)","dark khaki":"rgb(189,183,107)",khaki:"rgb(240,230,140)",olive:"rgb(128,128,0)",yellow:"rgb(255,255,0)","yellow green":"rgb(154,205,50)","dark olive green":"rgb(85,107,47)","olive drab":"rgb(107,142,35)","lawn green":"rgb(124,252,0)","chart reuse":"rgb(127,255,0)","green yellow":"rgb(173,255,47)","dark green":"rgb(0,100,0)",green:"rgb(0,128,0)","forest green":"rgb(34,139,34)",lime:"rgb(0,255,0)","lime green":"rgb(50,205,50)","light green":"rgb(144,238,144)","pale green":"rgb(152,251,152)","dark sea green":"rgb(143,188,143)","medium spring green":"rgb(0,250,154)","spring green":"rgb(0,255,127)","sea green":"rgb(46,139,87)","medium aqua marine":"rgb(102,205,170)","medium sea green":"rgb(60,179,113)","light sea green":"rgb(32,178,170)","dark slate gray":"rgb(47,79,79)",teal:"rgb(0,128,128)","dark cyan":"rgb(0,139,139)",cyan:"rgb(0,255,255)",aqua:"rgb(0,255,255)","light cyan":"rgb(224,255,255)","dark turquoise":"rgb(0,206,209)",turquoise:"rgb(64,224,208)","medium turquoise":"rgb(72,209,204)","pale turquoise":"rgb(175,238,238)","aqua marine":"rgb(127,255,212)","powder blue":"rgb(176,224,230)","cadet blue":"rgb(95,158,160)","steel blue":"rgb(70,130,180)","corn flower blue":"rgb(100,149,237)","deep sky blue":"rgb(0,191,255)","dodger blue":"rgb(30,144,255)","light blue":"rgb(173,216,230)","sky blue":"rgb(135,206,235)","light sky blue":"rgb(135,206,250)","midnight blue":"rgb(25,25,112)",navy:"rgb(0,0,128)","dark blue":"rgb(0,0,139)","medium blue":"rgb(0,0,205)",blue:"rgb(0,0,255)","royal blue":"rgb(65,105,225)","blue violet":"rgb(138,43,226)",indigo:"rgb(75,0,130)","dark slate blue":"rgb(72,61,139)","slate blue":"rgb(106,90,205)","medium slate blue":"rgb(123,104,238)","medium purple":"rgb(147,112,219)","dark magenta":"rgb(139,0,139)","dark violet":"rgb(148,0,211)","dark orchid":"rgb(153,50,204)","medium orchid":"rgb(186,85,211)",purple:"rgb(128,0,128)",thistle:"rgb(216,191,216)",plum:"rgb(221,160,221)",violet:"rgb(238,130,238)",magenta:"rgb(255,0,255)",fuchsia:"rgb(255,0,255)",orchid:"rgb(218,112,214)","medium violet red":"rgb(199,21,133)","pale violet red":"rgb(219,112,147)","deep pink":"rgb(255,20,147)","hot pink":"rgb(255,105,180)","light pink":"rgb(255,182,193)",pink:"rgb(255,192,203)","antique white":"rgb(250,235,215)",beige:"rgb(245,245,220)",bisque:"rgb(255,228,196)","blanched almond":"rgb(255,235,205)",wheat:"rgb(245,222,179)","corn silk":"rgb(255,248,220)","lemon chiffon":"rgb(255,250,205)","light golden rod yellow":"rgb(250,250,210)","light yellow":"rgb(255,255,224)","saddle brown":"rgb(139,69,19)",sienna:"rgb(160,82,45)",chocolate:"rgb(210,105,30)",peru:"rgb(205,133,63)","sandy brown":"rgb(244,164,96)","burly wood":"rgb(222,184,135)",tan:"rgb(210,180,140)","rosy brown":"rgb(188,143,143)",moccasin:"rgb(255,228,181)","navajo white":"rgb(255,222,173)","peach puff":"rgb(255,218,185)","misty rose":"rgb(255,228,225)","lavender blush":"rgb(255,240,245)",linen:"rgb(250,240,230)","old lace":"rgb(253,245,230)","papaya whip":"rgb(255,239,213)","sea shell":"rgb(255,245,238)","mint cream":"rgb(245,255,250)","slate gray":"rgb(112,128,144)","light slate gray":"rgb(119,136,153)","light steel blue":"rgb(176,196,222)",lavender:"rgb(230,230,250)","floral white":"rgb(255,250,240)","alice blue":"rgb(240,248,255)","ghost white":"rgb(248,248,255)",honeydew:"rgb(240,255,240)",ivory:"rgb(255,255,240)",azure:"rgb(240,255,255)",snow:"rgb(255,250,250)",black:"rgb(0,0,0)","dim gray":"rgb(105,105,105)","dim grey":"rgb(105,105,105)",gray:"rgb(128,128,128)",grey:"rgb(128,128,128)","dark gray":"rgb(169,169,169)","dark grey":"rgb(169,169,169)",silver:"rgb(192,192,192)","light gray":"rgb(211,211,211)","light grey":"rgb(211,211,211)",gainsboro:"rgb(220,220,220)",gainsborough:"rgb(220,220,220)","white smoke":"rgb(245,245,245)",white:"rgb(255,255,255)",transparent:"rgba(0,0,0,0)"};function b$2(e,t=[0,0,0,1]){var A,i;return null!==(i=null===(A=e.match(/\d{1,3}/g))||void 0===A?void 0:A.map((e=>+e)))&&void 0!==i?i:t}const a$9=e=>{e.prototype.name=function({exact:e=!0}={}){const{r:t,g:A,b:i,a:n}=this.rgba();if(0===n)return"transparent";const[a,r]=[Object.keys(e$9),Object.values(e$9)];let s;if(e){const e=this.stringRGB({alpha:!1}).replace(/\s/g,"");s=a.find((t=>e$9[t]===e))}else{let e=Number.POSITIVE_INFINITY;for(let n=0;n{for(var A in t)t$8.o(t,A)&&!t$8.o(e,A)&&Object.defineProperty(e,A,{enumerable:!0,get:t[A]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t)},a$8={};t$8.d(a$8,{Z:()=>d$1});const n$8=6/29,r$9=Math.pow(n$8,3),o$8=Math.pow(29/3,3),e$8={x:.96422,y:1,z:.82521};function c$8(e,t){return[e[0][0]*t[0]+e[0][1]*t[1]+e[0][2]*t[2],e[1][0]*t[0]+e[1][1]*t[1]+e[1][2]*t[2],e[2][0]*t[0]+e[2][1]*t[1]+e[2][2]*t[2]]}function s$8(e,t,A){return Math.max(e,Math.min(t,A))}function u$6(e){const t=e%360;return t<0?t+360:t}function i$8(e){const{l:t,a:A,b:i}=function(e){const t=Object.values(function(e){const[t,A,i]=c$8([[.41239079926595934,.357584339383878,.1804807884018343],[.21263900587151027,.715168678767756,.07219231536073371],[.01933081871559182,.11919477979462598,.9505321522496607]],Object.values(e).map((e=>{return 100*(t=e,(t/=255)<.04045?t/12.92:Math.pow((t+.055)/1.055,2.4));var t})));return function(e){const[t,A,i]=c$8([[1.0479298208405488,.022946793341019088,-.05019222954313557],[.029627815688159344,.990434484573249,-.01707382502938514],[-.009243058152591178,.015055144896577895,.7518742899580008]],Object.values(e));return{x:t,y:A,z:i,a:e.a}}({x:t,y:A,z:i,a:e.a})}(e)).map(((e,t)=>e/(100*Object.values(e$8)[t]))).map((e=>e>r$9?Math.cbrt(e):(o$8*e+16)/116));return{l:116*t[1]-16,a:500*(t[0]-t[1]),b:200*(t[1]-t[2]),alpha:e.a}}(e),n=180*Math.atan2(i,A)/Math.PI;return{l:t,c:Math.sqrt(Math.pow(A,2)+Math.pow(i,2)),h:u$6(n),a:e.a}}function h$2(e){const{l:t,c:A,h:i}=e;return function(e){const{l:t,a:A,b:i}=e,n=(t+16)/116,a=n+A/500,r=n-i/200,s=Object.values(e$8),[o,l,c]=[a,n,r].map(((e,t)=>(e>n$8?Math.pow(e,3):3*Math.pow(n$8,2)*(e-4/29))*s[t]*100));return function(e){const[t,A,i]=Object.values(function(e){const[t,A,i]=c$8([[.9554734527042182,-.023098536874261423,.0632593086610217],[-.028369706963208136,1.0099954580058226,.021041398966943008],[.012314001688319899,-.020507696433477912,1.3303659366080753]],Object.values(e));return{x:t,y:A,z:i,a:e.a}}(e)).map((e=>e/100)),[n,a,r]=c$8([[3.2409699419045226,-1.537383177570094,-.4986107602930034],[-.9692436362808796,1.8759675015077202,.04155505740717559],[.05563007969699366,-.20397695888897652,1.0569715142428786]],[t,A,i]).map((e=>{return s$8(0,255*((t=e)>.0031308?1.055*Math.pow(t,1/2.4)-.055:12.92*t),255);var t}));return{r:n,g:a,b:r,a:e.a}}({x:o,y:l,z:c,a:e.alpha})}({l:t,a:A*Math.cos(i*Math.PI/180),b:A*Math.sin(i*Math.PI/180),alpha:e.a})}const l$2=/lcha?\s*\(\s*(\d*\.?\d+%?)\s*,?\s*(\d*\.?\d+%?)\s*,?\s*([+-]?\d*\.?\d+%?)\s*,?\s*\/?\s*?(\d*\.?\d+%?)?\s*\)/gi;function p$1({l:e,c:t,h:A,a:i}){return[h$2({l:s$8(0,e,100),c:s$8(0,t,230),h:u$6(A),a:(n=i,void 0!==n?s$8(0,n,1):1)}),"lch"];var n}function f$1(e){if("object"===e.constructor.name.toLowerCase()&&function(e){const{l:t,c:A,h:i}=e;return void 0!==t&&void 0!==A&&void 0!==i}(e))return p$1(e);if("string"==typeof e){l$2.lastIndex=0;const t=l$2.exec(e);if(t){const[e,A,i,n]=t.filter((e=>void 0!==e)).slice(1).map(((e,t)=>e.includes("%")?+e.slice(0,-1)*(0===t?1:1===t?2.3:2===t?3.59:.01):+e));return p$1({l:e,c:A,h:i,a:n})}}return[{r:0,g:0,b:0,a:1},"invalid"]}const d$1=e=>{e.prototype.lcha=function(){return i$8(this.rgba())},e.prototype.stringLCH=function({alpha:e=!0,precision:t=[0,0,0,1]}={}){const[A,i,n,a]=Object.values(this.lcha()).map(((e,A)=>function(e,t){return+e.toFixed(t>=0?t:0)}(e,t[A])));return e?`lcha(${A}%, ${i}, ${n}, ${a})`:`lch(${A}%, ${i}, ${n})`},e.Parsers.push(f$1)};var b$1=a$8.Z,t$7={d:(e,t)=>{for(var A in t)t$7.o(t,A)&&!t$7.o(e,A)&&Object.defineProperty(e,A,{enumerable:!0,get:t[A]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t)},n$7={};t$7.d(n$7,{Z:()=>l$1});const r$8=Math.pow(6/29,3),e$7=Math.pow(29/3,3);function o$7(e,t){return[e[0][0]*t[0]+e[0][1]*t[1]+e[0][2]*t[2],e[1][0]*t[0]+e[1][1]*t[1]+e[1][2]*t[2],e[2][0]*t[0]+e[2][1]*t[1]+e[2][2]*t[2]]}function a$7(e,t,A){return Math.max(e,Math.min(t,A))}function u$5(e){const{l:t,u:A,v:i}=e,n=t>e$7*r$8?Math.pow((t+16)/116,3):t/e$7,a=(52*t/(A&&t?A+13*t*.20916005282038627:1)-1)/3,r=-5*n,s=n*(39*t/(i&&t?i+13*t*(9/18.43985):1)-5),o=a===-1/3?s-r:(s-r)/(a- -1/3);return function(e){const[t,A,i]=Object.values(function(e){const[t,A,i]=o$7([[.9554734527042182,-.023098536874261423,.0632593086610217],[-.028369706963208136,1.0099954580058226,.021041398966943008],[.012314001688319899,-.020507696433477912,1.3303659366080753]],Object.values(e));return{x:t,y:A,z:i,a:e.a}}(e)).map((e=>e/100)),[n,a,r]=o$7([[3.2409699419045226,-1.537383177570094,-.4986107602930034],[-.9692436362808796,1.8759675015077202,.04155505740717559],[.05563007969699366,-.20397695888897652,1.0569715142428786]],[t,A,i]).map((e=>{return a$7(0,255*((t=e)>.0031308?1.055*Math.pow(t,1/2.4)-.055:12.92*t),255);var t}));return{r:n,g:a,b:r,a:e.a}}({x:100*o,y:100*n,z:100*(a*o+r),a:e.a})}const c$7=/color\s*\(\s*luva?\s*(\d*\.?\d+%?)\s*,?\s*([+-]?\d*\.?\d+%?)\s*,?\s*([+-]?\d*\.?\d+%?)\s*,?\s*\/?\s*?(\d*\.?\d+%?)?\s*\)/gi;function s$7({l:e,u:t,v:A,a:i}){return[u$5({l:a$7(0,e,100),u:a$7(-100,t,100),v:a$7(-100,A,100),a:(n=i,void 0!==n?a$7(0,n,1):1)}),"luv"];var n}function i$7(e){if("object"===e.constructor.name.toLowerCase()&&function(e){const{l:t,u:A,v:i}=e;return void 0!==t&&void 0!==A&&null!=i}(e))return s$7(e);if("string"==typeof e){c$7.lastIndex=0;const t=c$7.exec(e);if(t){const[e,A,i,n]=t.filter((e=>void 0!==e)).slice(1).map(((e,t)=>e.includes("%")?+e.slice(0,-1)*(t<3?1:.01):+e));return s$7({l:e,u:A,v:i,a:n})}}return[{r:0,g:0,b:0,a:1},"invalid"]}const l$1=e=>{e.prototype.luva=function(){return function(e){const[t,A,i]=Object.values(function(e){const[t,A,i]=o$7([[.41239079926595934,.357584339383878,.1804807884018343],[.21263900587151027,.715168678767756,.07219231536073371],[.01933081871559182,.11919477979462598,.9505321522496607]],Object.values(e).map((e=>{return 100*(t=e,(t/=255)<.04045?t/12.92:Math.pow((t+.055)/1.055,2.4));var t})));return function(e){const[t,A,i]=o$7([[1.0479298208405488,.022946793341019088,-.05019222954313557],[.029627815688159344,.990434484573249,-.01707382502938514],[-.009243058152591178,.015055144896577895,.7518742899580008]],Object.values(e));return{x:t,y:A,z:i,a:e.a}}({x:t,y:A,z:i,a:e.a})}(e)).map((e=>e/100)),n=A/1,a=t&&A&&i?t+15*A+3*i:19,r=4*t/a,s=9*A/a;let o=n>r$8?116*Math.cbrt(n)-16:e$7*n,l=13*o*(r-.20916005282038627),c=13*o*(s-.48807338454488514);return o===Number(-0)&&(o=0),l===Number(-0)&&(l=0),c===Number(-0)&&(c=0),{l:o,u:l,v:c,a:e.a}}(this.rgba())},e.prototype.stringLUV=function({alpha:e=!0,precision:t=[0,0,0,1]}={}){const[A,i,n,a]=Object.values(this.luva()).map(((e,A)=>function(e,t){return+e.toFixed(t>=0?t:0)}(e,t[A])));return e?`color(luva ${A}%, ${i}%, ${n}%, ${a})`:`color(luv ${A}%, ${i}%, ${n}%)`},e.Parsers.push(i$7)};var v=n$7.Z,t$6={d:(e,t)=>{for(var A in t)t$6.o(t,A)&&!t$6.o(e,A)&&Object.defineProperty(e,A,{enumerable:!0,get:t[A]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t)},a$6={};t$6.d(a$6,{Z:()=>d});const n$6=6/29,r$7=Math.pow(n$6,3),e$6=Math.pow(29/3,3),o$6={x:.96422,y:1,z:.82521};function c$6(e,t){return[e[0][0]*t[0]+e[0][1]*t[1]+e[0][2]*t[2],e[1][0]*t[0]+e[1][1]*t[1]+e[1][2]*t[2],e[2][0]*t[0]+e[2][1]*t[1]+e[2][2]*t[2]]}function s$6(e,t,A){return Math.max(e,Math.min(t,A))}function u$4(e){return void 0!==e?s$6(0,e,1):1}function i$6(e){const t=Object.values(function(e){const[t,A,i]=c$6([[.41239079926595934,.357584339383878,.1804807884018343],[.21263900587151027,.715168678767756,.07219231536073371],[.01933081871559182,.11919477979462598,.9505321522496607]],Object.values(e).map((e=>{return 100*(t=e,(t/=255)<.04045?t/12.92:Math.pow((t+.055)/1.055,2.4));var t})));return function(e){const[t,A,i]=c$6([[1.0479298208405488,.022946793341019088,-.05019222954313557],[.029627815688159344,.990434484573249,-.01707382502938514],[-.009243058152591178,.015055144896577895,.7518742899580008]],Object.values(e));return{x:t,y:A,z:i,a:e.a}}({x:t,y:A,z:i,a:e.a})}(e)).map(((e,t)=>e/(100*Object.values(o$6)[t]))).map((e=>e>r$7?Math.cbrt(e):(e$6*e+16)/116));return{l:116*t[1]-16,a:500*(t[0]-t[1]),b:200*(t[1]-t[2]),alpha:e.a}}function l(e){const{l:t,a:A,b:i}=e,n=(t+16)/116,a=n+A/500,r=n-i/200,s=Object.values(o$6),[o,l,c]=[a,n,r].map(((e,t)=>(e>n$6?Math.pow(e,3):3*Math.pow(n$6,2)*(e-4/29))*s[t]*100));return function(e){const[t,A,i]=Object.values(function(e){const[t,A,i]=c$6([[.9554734527042182,-.023098536874261423,.0632593086610217],[-.028369706963208136,1.0099954580058226,.021041398966943008],[.012314001688319899,-.020507696433477912,1.3303659366080753]],Object.values(e));return{x:t,y:A,z:i,a:e.a}}(e)).map((e=>e/100)),[n,a,r]=c$6([[3.2409699419045226,-1.537383177570094,-.4986107602930034],[-.9692436362808796,1.8759675015077202,.04155505740717559],[.05563007969699366,-.20397695888897652,1.0569715142428786]],[t,A,i]).map((e=>{return s$6(0,255*((t=e)>.0031308?1.055*Math.pow(t,1/2.4)-.055:12.92*t),255);var t}));return{r:n,g:a,b:r,a:e.a}}({x:o,y:l,z:c,a:e.alpha})}const p=/laba?\s*\(\s*(\d*\.?\d+%?)\s*,?\s*([+-]?\d*\.?\d+)\s*,?\s*([+-]?\d*\.?\d+)\s*,?\s*\/?\s*?(\d*\.?\d+%?)?\s*\)/gi;function b({l:e,a:t,b:A,alpha:i}){return[l({l:s$6(0,e,100),a:s$6(-160,t,160),b:s$6(-160,A,160),alpha:u$4(i)}),"lab"]}function f(e){if("object"===e.constructor.name.toLowerCase()&&function(e){const{l:t,a:A,b:i}=e;return void 0!==t&&void 0!==A&&void 0!==i}(e))return b(e);if("string"==typeof e){p.lastIndex=0;const t=p.exec(e);if(t){const[e,A,i,n]=t.filter((e=>void 0!==e)).slice(1).map(((e,t)=>e.includes("%")?+e.slice(0,-1)*(t<3?1:.01):+e));return b({l:e,a:A,b:i,alpha:n})}}return[{r:0,g:0,b:0,a:1},"invalid"]}const d=e=>{e.prototype.laba=function(){return i$6(this.rgba())},e.prototype.stringLAB=function({alpha:e=!0,precision:t=[0,0,0,1]}={}){const[A,i,n,a]=Object.values(this.laba()).map(((e,A)=>function(e,t){return+e.toFixed(t>=0?t:0)}(e,t[A])));return e?`laba(${A}%, ${i}, ${n}, ${a})`:`lab(${A}%, ${i}, ${n})`},e.Parsers.push(f)};var h$1=a$6.Z,t$5={d:(e,t)=>{for(var A in t)t$5.o(t,A)&&!t$5.o(e,A)&&Object.defineProperty(e,A,{enumerable:!0,get:t[A]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t)},n$5={};function r$6(e,t){return[e[0][0]*t[0]+e[0][1]*t[1]+e[0][2]*t[2],e[1][0]*t[0]+e[1][1]*t[1]+e[1][2]*t[2],e[2][0]*t[0]+e[2][1]*t[1]+e[2][2]*t[2]]}function o$5(e,t,A){return Math.max(e,Math.min(t,A))}function e$5(e){const{u:t,v:A,w:i}=e,[n,a,r]=r$6([[1.5,0,0],[0,1,0],[1.5,-3,2]],[t,A,i]);return function(e){const[t,A,i]=Object.values(function(e){const[t,A,i]=r$6([[.9554734527042182,-.023098536874261423,.0632593086610217],[-.028369706963208136,1.0099954580058226,.021041398966943008],[.012314001688319899,-.020507696433477912,1.3303659366080753]],Object.values(e));return{x:t,y:A,z:i,a:e.a}}(e)).map((e=>e/100)),[n,a,r]=r$6([[3.2409699419045226,-1.537383177570094,-.4986107602930034],[-.9692436362808796,1.8759675015077202,.04155505740717559],[.05563007969699366,-.20397695888897652,1.0569715142428786]],[t,A,i]).map((e=>{return o$5(0,255*((t=e)>.0031308?1.055*Math.pow(t,1/2.4)-.055:12.92*t),255);var t}));return{r:n,g:a,b:r,a:e.a}}({x:n,y:a,z:r,a:e.a})}t$5.d(n$5,{Z:()=>s$5});const a$5=/color\s*\(\s*uvwa?\s*(\d*\.?\d+)\s*,?\s*([+-]?\d*\.?\d+)\s*,?\s*([+-]?\d*\.?\d+)\s*,?\s*\/?\s*?(\d*\.?\d+%?)?\s*\)/gi;function u$3({u:e,v:t,w:A,a:i}){return[e$5({u:o$5(0,e,200/3*.96422),v:o$5(0,t,100),w:o$5(-48.211,A,191.2605),a:(n=i,void 0!==n?o$5(0,n,1):1)}),"uvw"];var n}function c$5(e){if("object"===e.constructor.name.toLowerCase()&&function(e){const{u:t,v:A,w:i}=e;return void 0!==t&&void 0!==A&&void 0!==i}(e))return u$3(e);if("string"==typeof e){a$5.lastIndex=0;const t=a$5.exec(e);if(t){const[e,A,i,n]=t.filter((e=>void 0!==e)).slice(1).map((e=>e.includes("%")?.01*+e.slice(0,-1):+e));return u$3({u:e,v:A,w:i,a:n})}}return[{r:0,g:0,b:0,a:1},"invalid"]}const s$5=e=>{e.prototype.uvwa=function(){return function(e){const{x:t,y:A,z:i}=function(e){const[t,A,i]=r$6([[.41239079926595934,.357584339383878,.1804807884018343],[.21263900587151027,.715168678767756,.07219231536073371],[.01933081871559182,.11919477979462598,.9505321522496607]],Object.values(e).map((e=>{return 100*(t=e,(t/=255)<.04045?t/12.92:Math.pow((t+.055)/1.055,2.4));var t})));return function(e){const[t,A,i]=r$6([[1.0479298208405488,.022946793341019088,-.05019222954313557],[.029627815688159344,.990434484573249,-.01707382502938514],[-.009243058152591178,.015055144896577895,.7518742899580008]],Object.values(e));return{x:t,y:A,z:i,a:e.a}}({x:t,y:A,z:i,a:e.a})}(e),[n,a,r]=r$6([[2/3,0,0],[0,1,0],[-.5,1.5,.5]],[t,A,i]);return{u:n,v:a,w:r,a:e.a}}(this.rgba())},e.prototype.stringUVW=function({alpha:e=!0,precision:t=[0,0,0,1]}={}){const[A,i,n,a]=Object.values(this.uvwa()).map(((e,A)=>function(e,t){return+e.toFixed(t>=0?t:0)}(e,t[A])));return e?`color(uvwa ${A}, ${i}, ${n}, ${a})`:`color(uvw ${A}, ${i}, ${n})`},e.Parsers.push(c$5)};var i$5=n$5.Z,t$4={d:(e,t)=>{for(var A in t)t$4.o(t,A)&&!t$4.o(e,A)&&Object.defineProperty(e,A,{enumerable:!0,get:t[A]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t)},n$4={};function r$5(e,t){return[e[0][0]*t[0]+e[0][1]*t[1]+e[0][2]*t[2],e[1][0]*t[0]+e[1][1]*t[1]+e[1][2]*t[2],e[2][0]*t[0]+e[2][1]*t[1]+e[2][2]*t[2]]}function o$4(e,t,A){return Math.max(e,Math.min(t,A))}function e$4(e){const[t,A,i]=Object.values(function(e){const[t,A,i]=r$5([[.9554734527042182,-.023098536874261423,.0632593086610217],[-.028369706963208136,1.0099954580058226,.021041398966943008],[.012314001688319899,-.020507696433477912,1.3303659366080753]],Object.values(e));return{x:t,y:A,z:i,a:e.a}}(e)).map((e=>e/100)),[n,a,r]=r$5([[3.2409699419045226,-1.537383177570094,-.4986107602930034],[-.9692436362808796,1.8759675015077202,.04155505740717559],[.05563007969699366,-.20397695888897652,1.0569715142428786]],[t,A,i]).map((e=>{return o$4(0,255*((t=e)>.0031308?1.055*Math.pow(t,1/2.4)-.055:12.92*t),255);var t}));return{r:n,g:a,b:r,a:e.a}}t$4.d(n$4,{Z:()=>u$2});const a$4=/color\s*\(\s*xyza?\s*(\d*\.?\d+)\s*,?\s*(\d*\.?\d+)\s*,?\s*(\d*\.?\d+)\s*,?\s*\/?\s*?(\d*\.?\d+%?)?\s*\)/gi;function s$4({x:e,y:t,z:A,a:i}){return[e$4({x:o$4(0,e,96.422),y:o$4(0,t,100),z:o$4(0,A,82.521),a:(n=i,void 0!==n?o$4(0,n,1):1)}),"xyz"];var n}function c$4(e){if("object"===e.constructor.name.toLowerCase()&&function(e){const{x:t,y:A,z:i}=e;return void 0!==t&&void 0!==A&&void 0!==i}(e))return s$4(e);if("string"==typeof e){a$4.lastIndex=0;const t=a$4.exec(e);if(t){const[e,A,i,n]=t.filter((e=>void 0!==e)).slice(1).map((e=>e.includes("%")?.01*+e.slice(0,-1):+e));return s$4({x:e,y:A,z:i,a:n})}}return[{r:0,g:0,b:0,a:1},"invalid"]}const u$2=e=>{e.prototype.xyza=function(){return function(e){const[t,A,i]=r$5([[.41239079926595934,.357584339383878,.1804807884018343],[.21263900587151027,.715168678767756,.07219231536073371],[.01933081871559182,.11919477979462598,.9505321522496607]],Object.values(e).map((e=>{return 100*(t=e,(t/=255)<.04045?t/12.92:Math.pow((t+.055)/1.055,2.4));var t})));return function(e){const[t,A,i]=r$5([[1.0479298208405488,.022946793341019088,-.05019222954313557],[.029627815688159344,.990434484573249,-.01707382502938514],[-.009243058152591178,.015055144896577895,.7518742899580008]],Object.values(e));return{x:t,y:A,z:i,a:e.a}}({x:t,y:A,z:i,a:e.a})}(this.rgba())},e.prototype.stringXYZ=function({alpha:e=!0,precision:t=[0,0,0,1]}={}){const[A,i,n,a]=Object.values(this.xyza()).map(((e,A)=>function(e,t){return+e.toFixed(t>=0?t:0)}(e,t[A])));return e?`color(xyza ${A}, ${i}, ${n}, ${a})`:`color(xyz ${A}, ${i}, ${n})`},e.Parsers.push(c$4)};var i$4=n$4.Z,t$3={d:(e,t)=>{for(var A in t)t$3.o(t,A)&&!t$3.o(e,A)&&Object.defineProperty(e,A,{enumerable:!0,get:t[A]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t)},n$3={};function r$4(e,t,A){return Math.max(e,Math.min(t,A))}function a$3(e){const t=e%360;return t<0?t+360:t}function o$3(e){const{h:t,a:A}=function(e){var t;const{Cmin:A,Cmax:i,H:n,delta:a}=function(e){const[t,A,i]=Object.values(e).map((e=>e/255)),n=Math.max(t,A,i),a=Math.min(t,A,i),r=n-a;return{Cmin:a,Cmax:n,H:0===r?0:n===t?(A-i)/r%6:n===A?(i-t)/r+2:(t-A)/r+4,delta:r}}(e),r=(i+A)/2,s=0===a?0:a/(1-Math.abs(2*r-1));return{h:a$3(60*n),s:100*s,l:100*r,a:null!==(t=e.a)&&void 0!==t?t:1}}(e),{r:i,g:n,b:a}=e;return{h:t,w:Math.min(i,n,a)/2.55,b:100*(1-Math.max(i,n,a)/255),a:A}}function e$3(e){const{h:t,b:A,w:i,a:n}=e;return function(e){const{h:t,s:A,v:i,a:n}=e,a=i/100,r=a*(A/100),s=r*(1-Math.abs(t/60%2-1)),o=a-r,l=t<60||300<=t&&t<360?r:120<=t&&t<240?0:s,c=240<=t&&t<360?0:60<=t&&t<180?r:s,d=t<120?0:180<=t&&t<300?r:s,[h,u,g]=[l,c,d].map((e=>255*(e+o)));return{r:h,g:u,b:g,a:null!=n?n:1}}({h:t,s:100===A?0:100-i/(100-A)*100,v:100-A,a:n})}t$3.d(n$3,{Z:()=>u$1});const s$3=/hwba?\s*\(\s*([+-]?\d*\.?\d+%?)\s*,?\s*(\d*\.?\d+%?)\s*,?\s*(\d*\.?\d+%?)\s*,?\s*\/?\s*?(\d*\.?\d+%?)?\s*\)/gi;function i$3({h:e,w:t,b:A,a:i}){return[e$3({h:a$3(e),w:r$4(0,t,100),b:r$4(0,A,100),a:(n=i,void 0!==n?r$4(0,n,1):1)}),"hwb"];var n}function c$3(e){if("object"===e.constructor.name.toLowerCase()&&function(e){const{h:t,w:A,b:i}=e;return void 0!==t&&void 0!==A&&void 0!==i}(e))return i$3(e);if("string"==typeof e){s$3.lastIndex=0;const t=s$3.exec(e);if(t){const[e,A,i,n]=t.filter((e=>void 0!==e)).slice(1).map(((e,t)=>e.includes("%")?+e.slice(0,-1)*(0===t?3.59:t<3?1:.01):+e));return i$3({h:e,w:A,b:i,a:n})}}return[{r:0,g:0,b:0,a:1},"invalid"]}const u$1=e=>{e.prototype.hwba=function(){return o$3(this.rgba())},e.prototype.stringHWB=function({alpha:e=!0,precision:t=[0,0,0,1]}={}){const[A,i,n,a]=Object.values(this.hwba()).map(((e,A)=>function(e,t){return+e.toFixed(t>=0?t:0)}(e,t[A])));return e?`hwba(${a$3(A)}, ${i}%, ${n}%, ${a})`:`hwb(${a$3(A)}, ${i}%, ${n}%)`},e.Parsers.push(c$3)};var h=n$3.Z,t$2={d:(e,t)=>{for(var A in t)t$2.o(t,A)&&!t$2.o(e,A)&&Object.defineProperty(e,A,{enumerable:!0,get:t[A]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t)},n$2={};function r$3(e,t,A){return Math.max(e,Math.min(t,A))}function s$2(e){const t=e%360;return t<0?t+360:t}function e$2(e){const{h:t,s:A,v:i,a:n}=e,a=i/100,r=a*(A/100),s=r*(1-Math.abs(t/60%2-1)),o=a-r,l=t<60||300<=t&&t<360?r:120<=t&&t<240?0:s,c=240<=t&&t<360?0:60<=t&&t<180?r:s,d=t<120?0:180<=t&&t<300?r:s,[h,u,g]=[l,c,d].map((e=>255*(e+o)));return{r:h,g:u,b:g,a:null!=n?n:1}}t$2.d(n$2,{Z:()=>c$2});const a$2=/hsva?\s*\(\s*([+-]?\d*\.?\d+%?)\s*,?\s*(\d*\.?\d+%?)\s*,?\s*(\d*\.?\d+%?)\s*,?\s*\/?\s*?(\d*\.?\d+%?)?\s*\)/gi;function o$2({h:e,s:t,v:A,a:i}){return[e$2({h:s$2(e),s:r$3(0,t,100),v:r$3(0,A,100),a:(n=i,void 0!==n?r$3(0,n,1):1)}),"hsv"];var n}function i$2(e){if("object"===e.constructor.name.toLowerCase()&&function(e){const{h:t,s:A,v:i}=e;return void 0!==t&&void 0!==A&&void 0!==i}(e))return o$2(e);if("string"==typeof e){a$2.lastIndex=0;const t=a$2.exec(e);if(t){const[e,A,i,n]=t.filter((e=>void 0!==e)).slice(1).map(((e,t)=>e.includes("%")?+e.slice(0,-1)*(0===t?3.59:t<3?1:.01):+e));return o$2({h:e,s:A,v:i,a:n})}}return[{r:0,g:0,b:0,a:1},"invalid"]}const c$2=e=>{e.prototype.hsva=function(){return function(e){var t;const{Cmax:A,H:i,delta:n}=function(e){const[t,A,i]=Object.values(e).map((e=>e/255)),n=Math.max(t,A,i),a=Math.min(t,A,i),r=n-a;return{Cmin:a,Cmax:n,H:0===r?0:n===t?(A-i)/r%6:n===A?(i-t)/r+2:(t-A)/r+4,delta:r}}(e),a=0===n?0:n/A;return{h:s$2(60*i),s:100*a,v:100*A,a:null!==(t=e.a)&&void 0!==t?t:1}}(this.rgba())},e.prototype.stringHSV=function({alpha:e=!0,precision:t=[0,0,0,1]}={}){const[A,i,n,a]=Object.values(this.hsva()).map(((e,A)=>function(e,t){return+e.toFixed(t>=0?t:0)}(e,t[A])));return e?`hsva(${s$2(A)}, ${i}%, ${n}%, ${a})`:`hsv(${s$2(A)}, ${i}%, ${n}%)`},e.Parsers.push(i$2)};var u=n$2.Z,t$1={d:(e,t)=>{for(var A in t)t$1.o(t,A)&&!t$1.o(e,A)&&Object.defineProperty(e,A,{enumerable:!0,get:t[A]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t)},r$2={};function n$1(e,t,A){return Math.max(e,Math.min(t,A))}function o$1(e){let{r:t,y:A,b:i}=e;const n=Math.min(t,A,i);[t,A,i]=[t,A,i].map((e=>e-n));const a=Math.max(t,A,i);let r=Math.min(A,i);A-=r,i-=r,i&&r&&(i*=2,r*=2),t+=A,r+=A;const s=Math.max(t,r,i);if(s){const e=a/s;[t,r,i]=[t,r,i].map((t=>t*e))}return[t,r,i]=[t,r,i].map((e=>e+n)),{r:t,g:r,b:i,a:e.a}}t$1.d(r$2,{Z:()=>i$1});const a$1=/color\s*\(\s*ryba?\s*(\d*\.?\d+%?)\s*,?\s*(\d*\.?\d+%?)\s*,?\s*(\d*\.?\d+%?)\s*,?\s*\/?\s*?(\d*\.?\d+%?)?\s*\)/gi;function e$1({r:e,y:t,b:A,a:i}){return[o$1({r:n$1(0,e,255),y:n$1(0,t,255),b:n$1(0,A,255),a:(n=i,void 0!==n?n$1(0,n,1):1)}),"ryb"];var n}function s$1(e){if("object"===e.constructor.name.toLowerCase()&&function(e){const{r:t,y:A,b:i}=e;return void 0!==t&&void 0!==A&&void 0!==i}(e))return e$1(e);if("string"==typeof e){a$1.lastIndex=0;const t=a$1.exec(e);if(t){const[e,A,i,n]=t.filter((e=>void 0!==e)).slice(1).map(((e,t)=>e.includes("%")?+e.slice(0,-1)*(t<3?2.55:.01):+e));return e$1({r:e,y:A,b:i,a:n})}}return[{r:0,g:0,b:0,a:1},"invalid"]}const i$1=e=>{e.prototype.ryba=function(){return function(e){let{r:t,g:A,b:i}=e;const n=Math.min(t,A,i);[t,A,i]=[t,A,i].map((e=>e-n));const a=Math.max(t,A,i);let r=Math.min(t,A);t-=r,A-=r,i&&A&&(i/=2,A/=2),r+=A,i+=A;const s=Math.max(t,r,i);if(s){const e=a/s;[t,r,i]=[t,r,i].map((t=>t*e))}return[t,r,i]=[t,r,i].map((e=>e+n)),{r:t,y:r,b:i,a:e.a}}(this.rgba())},e.prototype.stringRYB=function({alpha:e=!0,precision:t=[0,0,0,1]}={}){const[A,i,n,a]=Object.values(this.ryba()).map(((e,A)=>function(e,t){return+e.toFixed(t>=0?t:0)}(e,t[A])));return e?`color(ryba ${A}, ${i}, ${n}, ${a})`:`color(ryb ${A}, ${i}, ${n})`},e.Parsers.push(s$1)};var c$1=r$2.Z,t={d:(e,A)=>{for(var i in A)t.o(A,i)&&!t.o(e,i)&&Object.defineProperty(e,i,{enumerable:!0,get:A[i]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t)},n={};function e(e,t,A){return Math.max(e,Math.min(t,A))}function r$1(e){const{c:t,m:A,y:i,k:n,a:a}=e,[r,s,o]=[t,A,i].map((e=>255*(1-e/100)*(1-n/100)));return{r:r,g:s,b:o,a:a}}t.d(n,{Z:()=>i});const c=/device-cmyka?\s*\(\s*(\d*\.?\d+%?)\s*,?\s*(\d*\.?\d+%?)\s*,?\s*(\d*\.?\d+%?)\s*,?\s*(\d*\.?\d+%?),?\s*\/?\s*?(\d*\.?\d+%?)?\s*\)/gi;function o({c:t,m:A,y:i,k:n,a:a}){return[r$1({c:e(0,t,100),m:e(0,A,100),y:e(0,i,100),k:e(0,n,100),a:(r=a,void 0!==r?e(0,r,1):1)}),"cmyk"];var r}function a(e){if("object"===e.constructor.name.toLowerCase()&&function(e){const{c:t,m:A,y:i,k:n}=e;return void 0!==t&&void 0!==A&&void 0!==i&&void 0!==n}(e))return o(e);if("string"==typeof e){c.lastIndex=0;const t=c.exec(e);if(t){const[e,A,i,n,a]=t.filter((e=>void 0!==e)).slice(1).map(((e,t)=>e.includes("%")?+e.slice(0,-1)*(t<4?1:.01):+e));return o({c:e,m:A,y:i,k:n,a:a})}}return[{r:0,g:0,b:0,a:1},"invalid"]}const i=e=>{e.prototype.cmyka=function(){return function(e){const{r:t,g:A,b:i,a:n}=e,a=1-Math.max(t,A,i)/255,[r,s,o]=1===a?[0,0,0]:[t,A,i].map((e=>100*(1-e/255-a)/(1-a)));return{c:r,m:s,y:o,k:100*a,a:n}}(this.rgba())},e.prototype.stringCMYK=function({alpha:e=!0,precision:t=[0,0,0,0,1]}={}){const[A,i,n,a,r]=Object.values(this.cmyka()).map(((e,A)=>function(e,t){return+e.toFixed(t>=0?t:0)}(e,t[A])));return e?`device-cmyk(${A}, ${i}, ${n}, ${a}, ${r})`:`device-cmyk(${A}, ${i}, ${n}, ${a})`},e.Parsers.push(a)};var s=n.Z;class ExcalidrawScene{constructor(e=[]){this.type="excalidraw",this.version=2,this.source=GITHUB_RELEASES+PLUGIN_VERSION,this.elements=[],this.elements=e}toExJSON(){return Object.assign(Object.assign({},this),{elements:this.elements.map((e=>Object.assign({},e)))})}}var ARRAY_TYPE="undefined"!=typeof Float32Array?Float32Array:Array;function create$1(){var e=new ARRAY_TYPE(16);return ARRAY_TYPE!=Float32Array&&(e[1]=0,e[2]=0,e[3]=0,e[4]=0,e[6]=0,e[7]=0,e[8]=0,e[9]=0,e[11]=0,e[12]=0,e[13]=0,e[14]=0),e[0]=1,e[5]=1,e[10]=1,e[15]=1,e}function clone(e){var t=new ARRAY_TYPE(16);return t[0]=e[0],t[1]=e[1],t[2]=e[2],t[3]=e[3],t[4]=e[4],t[5]=e[5],t[6]=e[6],t[7]=e[7],t[8]=e[8],t[9]=e[9],t[10]=e[10],t[11]=e[11],t[12]=e[12],t[13]=e[13],t[14]=e[14],t[15]=e[15],t}function fromValues$1(e,t,A,i,n,a,r,s,o,l,c,d,h,u,g,p){var m=new ARRAY_TYPE(16);return m[0]=e,m[1]=t,m[2]=A,m[3]=i,m[4]=n,m[5]=a,m[6]=r,m[7]=s,m[8]=o,m[9]=l,m[10]=c,m[11]=d,m[12]=h,m[13]=u,m[14]=g,m[15]=p,m}function multiply(e,t,A){var i=t[0],n=t[1],a=t[2],r=t[3],s=t[4],o=t[5],l=t[6],c=t[7],d=t[8],h=t[9],u=t[10],g=t[11],p=t[12],m=t[13],w=t[14],f=t[15],E=A[0],B=A[1],b=A[2],v=A[3];return e[0]=E*i+B*s+b*d+v*p,e[1]=E*n+B*o+b*h+v*m,e[2]=E*a+B*l+b*u+v*w,e[3]=E*r+B*c+b*g+v*f,E=A[4],B=A[5],b=A[6],v=A[7],e[4]=E*i+B*s+b*d+v*p,e[5]=E*n+B*o+b*h+v*m,e[6]=E*a+B*l+b*u+v*w,e[7]=E*r+B*c+b*g+v*f,E=A[8],B=A[9],b=A[10],v=A[11],e[8]=E*i+B*s+b*d+v*p,e[9]=E*n+B*o+b*h+v*m,e[10]=E*a+B*l+b*u+v*w,e[11]=E*r+B*c+b*g+v*f,E=A[12],B=A[13],b=A[14],v=A[15],e[12]=E*i+B*s+b*d+v*p,e[13]=E*n+B*o+b*h+v*m,e[14]=E*a+B*l+b*u+v*w,e[15]=E*r+B*c+b*g+v*f,e}function create(){var e=new ARRAY_TYPE(3);return ARRAY_TYPE!=Float32Array&&(e[0]=0,e[1]=0,e[2]=0),e}function fromValues(e,t,A){var i=new ARRAY_TYPE(3);return i[0]=e,i[1]=t,i[2]=A,i}function transformMat4(e,t,A){var i=t[0],n=t[1],a=t[2],r=A[3]*i+A[7]*n+A[11]*a+A[15];return r=r||1,e[0]=(A[0]*i+A[4]*n+A[8]*a+A[12])/r,e[1]=(A[1]*i+A[5]*n+A[9]*a+A[13])/r,e[2]=(A[2]*i+A[6]*n+A[10]*a+A[14])/r,e}Math.hypot||(Math.hypot=function(){for(var e=0,t=arguments.length;t--;)e+=arguments[t]*arguments[t];return Math.sqrt(e)}),create();const random=new Random(Date.now()),randomInteger=()=>Math.floor(random.next()*2**31),randomId=()=>nanoid$1();function dimensionsFromPoints(e){const t=e.map((([e])=>e)),A=e.map((([,e])=>e)),i=Math.min(...t),n=Math.min(...A);return[Math.max(...t)-i,Math.max(...A)-n]}function getWindingOrder(e){return e.reduce(((e,[t,A],i,n)=>{const a=n[i+1];return((a?a[0]:0)-t)*((a?a[1]:0)+A)+e}),0)>0?"clockwise":"counterclockwise"}var chromaExports={},chroma$1={get exports(){return chromaExports},set exports(e){chromaExports=e}};chroma$1.exports=function(){for(var e=function(e,t,A){return void 0===t&&(t=0),void 0===A&&(A=1),eA?A:e},t=e,A={},i=0,n=["Boolean","Number","String","Function","Array","Date","RegExp","Undefined","Null"];i255)&&(e._clipped=!0),e[A]=t(e[A],0,255)):3===A&&(e[A]=t(e[A],0,1));return e},limit:e,type:r,unpack:function(e,t){return void 0===t&&(t=null),e.length>=3?Array.prototype.slice.call(e):"object"==s(e[0])&&t?t.split("").filter((function(t){return void 0!==e[0][t]})).map((function(t){return e[0][t]})):e[0]},last:function(e){if(e.length<2)return null;var t=e.length-1;return"string"==o(e[t])?e[t].toLowerCase():null},PI:l,TWOPI:2*l,PITHIRD:l/3,DEG2RAD:l/180,RAD2DEG:180/l},d={format:{},autodetect:[]},h=c.last,u=c.clip_rgb,g=c.type,p=d,m=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var A=this;if("object"===g(e[0])&&e[0].constructor&&e[0].constructor===this.constructor)return e[0];var i=h(e),n=!1;if(!i){n=!0,p.sorted||(p.autodetect=p.autodetect.sort((function(e,t){return t.p-e.p})),p.sorted=!0);for(var a=0,r=p.autodetect;a4?e[4]:1;return 1===a?[0,0,0,r]:[A>=1?0:255*(1-A)*(1-a),i>=1?0:255*(1-i)*(1-a),n>=1?0:255*(1-n)*(1-a),r]},F=E,x=w,S=d,T=c.unpack,I=c.type,k=v;x.prototype.cmyk=function(){return k(this._rgb)},F.cmyk=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];return new(Function.prototype.bind.apply(x,[null].concat(e,["cmyk"])))},S.format.cmyk=y,S.autodetect.push({p:2,test:function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];if(e=T(e,"cmyk"),"array"===I(e)&&4===e.length)return"cmyk"}});var U=c.unpack,Q=c.last,O=function(e){return Math.round(100*e)/100},L=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var A=U(e,"hsla"),i=Q(e)||"lsa";return A[0]=O(A[0]||0),A[1]=O(100*A[1])+"%",A[2]=O(100*A[2])+"%","hsla"===i||A.length>3&&A[3]<1?(A[3]=A.length>3?A[3]:1,i="hsla"):A.length=3,i+"("+A.join(",")+")"},M=c.unpack,N=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var A=(e=M(e,"rgba"))[0],i=e[1],n=e[2];A/=255,i/=255,n/=255;var a,r,s=Math.min(A,i,n),o=Math.max(A,i,n),l=(o+s)/2;return o===s?(a=0,r=Number.NaN):a=l<.5?(o-s)/(o+s):(o-s)/(2-o-s),A==o?r=(i-n)/(o-s):i==o?r=2+(n-A)/(o-s):n==o&&(r=4+(A-i)/(o-s)),(r*=60)<0&&(r+=360),e.length>3&&void 0!==e[3]?[r,a,l,e[3]]:[r,a,l]},D=c.unpack,R=c.last,H=L,P=N,V=Math.round,K=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var A=D(e,"rgba"),i=R(e)||"rgb";return"hsl"==i.substr(0,3)?H(P(A),i):(A[0]=V(A[0]),A[1]=V(A[1]),A[2]=V(A[2]),("rgba"===i||A.length>3&&A[3]<1)&&(A[3]=A.length>3?A[3]:1,i="rgba"),i+"("+A.slice(0,"rgb"===i?3:4).join(",")+")")},G=c.unpack,W=Math.round,z=function(){for(var e,t=[],A=arguments.length;A--;)t[A]=arguments[A];var i,n,a,r=(t=G(t,"hsl"))[0],s=t[1],o=t[2];if(0===s)i=n=a=255*o;else{var l=[0,0,0],c=[0,0,0],d=o<.5?o*(1+s):o+s-o*s,h=2*o-d,u=r/360;l[0]=u+1/3,l[1]=u,l[2]=u-1/3;for(var g=0;g<3;g++)l[g]<0&&(l[g]+=1),l[g]>1&&(l[g]-=1),6*l[g]<1?c[g]=h+6*(d-h)*l[g]:2*l[g]<1?c[g]=d:3*l[g]<2?c[g]=h+(d-h)*(2/3-l[g])*6:c[g]=h;i=(e=[W(255*c[0]),W(255*c[1]),W(255*c[2])])[0],n=e[1],a=e[2]}return t.length>3?[i,n,a,t[3]]:[i,n,a,1]},X=z,Y=d,j=/^rgb\(\s*(-?\d+),\s*(-?\d+)\s*,\s*(-?\d+)\s*\)$/,_=/^rgba\(\s*(-?\d+),\s*(-?\d+)\s*,\s*(-?\d+)\s*,\s*([01]|[01]?\.\d+)\)$/,J=/^rgb\(\s*(-?\d+(?:\.\d+)?)%,\s*(-?\d+(?:\.\d+)?)%\s*,\s*(-?\d+(?:\.\d+)?)%\s*\)$/,Z=/^rgba\(\s*(-?\d+(?:\.\d+)?)%,\s*(-?\d+(?:\.\d+)?)%\s*,\s*(-?\d+(?:\.\d+)?)%\s*,\s*([01]|[01]?\.\d+)\)$/,q=/^hsl\(\s*(-?\d+(?:\.\d+)?),\s*(-?\d+(?:\.\d+)?)%\s*,\s*(-?\d+(?:\.\d+)?)%\s*\)$/,$=/^hsla\(\s*(-?\d+(?:\.\d+)?),\s*(-?\d+(?:\.\d+)?)%\s*,\s*(-?\d+(?:\.\d+)?)%\s*,\s*([01]|[01]?\.\d+)\)$/,ee=Math.round,te=function(e){var t;if(e=e.toLowerCase().trim(),Y.format.named)try{return Y.format.named(e)}catch(e){}if(t=e.match(j)){for(var A=t.slice(1,4),i=0;i<3;i++)A[i]=+A[i];return A[3]=1,A}if(t=e.match(_)){for(var n=t.slice(1,5),a=0;a<4;a++)n[a]=+n[a];return n}if(t=e.match(J)){for(var r=t.slice(1,4),s=0;s<3;s++)r[s]=ee(2.55*r[s]);return r[3]=1,r}if(t=e.match(Z)){for(var o=t.slice(1,5),l=0;l<3;l++)o[l]=ee(2.55*o[l]);return o[3]=+o[3],o}if(t=e.match(q)){var c=t.slice(1,4);c[1]*=.01,c[2]*=.01;var d=X(c);return d[3]=1,d}if(t=e.match($)){var h=t.slice(1,4);h[1]*=.01,h[2]*=.01;var u=X(h);return u[3]=+t[4],u}};te.test=function(e){return j.test(e)||_.test(e)||J.test(e)||Z.test(e)||q.test(e)||$.test(e)};var Ae=E,ie=w,ne=d,ae=c.type,re=K,se=te;ie.prototype.css=function(e){return re(this._rgb,e)},Ae.css=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];return new(Function.prototype.bind.apply(ie,[null].concat(e,["css"])))},ne.format.css=se,ne.autodetect.push({p:5,test:function(e){for(var t=[],A=arguments.length-1;A-- >0;)t[A]=arguments[A+1];if(!t.length&&"string"===ae(e)&&se.test(e))return"css"}});var oe=w,le=E,ce=c.unpack;d.format.gl=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var A=ce(e,"rgba");return A[0]*=255,A[1]*=255,A[2]*=255,A},le.gl=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];return new(Function.prototype.bind.apply(oe,[null].concat(e,["gl"])))},oe.prototype.gl=function(){var e=this._rgb;return[e[0]/255,e[1]/255,e[2]/255,e[3]]};var de=c.unpack,he=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var A,i=de(e,"rgb"),n=i[0],a=i[1],r=i[2],s=Math.min(n,a,r),o=Math.max(n,a,r),l=o-s,c=100*l/255,d=s/(255-l)*100;return 0===l?A=Number.NaN:(n===o&&(A=(a-r)/l),a===o&&(A=2+(r-n)/l),r===o&&(A=4+(n-a)/l),(A*=60)<0&&(A+=360)),[A,c,d]},ue=c.unpack,ge=Math.floor,pe=function(){for(var e,t,A,i,n,a,r=[],s=arguments.length;s--;)r[s]=arguments[s];var o,l,c,d=(r=ue(r,"hcg"))[0],h=r[1],u=r[2];u*=255;var g=255*h;if(0===h)o=l=c=u;else{360===d&&(d=0),d>360&&(d-=360),d<0&&(d+=360);var p=ge(d/=60),m=d-p,w=u*(1-h),f=w+g*(1-m),E=w+g*m,B=w+g;switch(p){case 0:o=(e=[B,E,w])[0],l=e[1],c=e[2];break;case 1:o=(t=[f,B,w])[0],l=t[1],c=t[2];break;case 2:o=(A=[w,B,E])[0],l=A[1],c=A[2];break;case 3:o=(i=[w,f,B])[0],l=i[1],c=i[2];break;case 4:o=(n=[E,w,B])[0],l=n[1],c=n[2];break;case 5:o=(a=[B,w,f])[0],l=a[1],c=a[2]}}return[o,l,c,r.length>3?r[3]:1]},me=c.unpack,we=c.type,fe=E,Ee=w,Be=d,be=he;Ee.prototype.hcg=function(){return be(this._rgb)},fe.hcg=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];return new(Function.prototype.bind.apply(Ee,[null].concat(e,["hcg"])))},Be.format.hcg=pe,Be.autodetect.push({p:1,test:function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];if(e=me(e,"hcg"),"array"===we(e)&&3===e.length)return"hcg"}});var ve=c.unpack,Ce=c.last,ye=Math.round,Fe=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var A=ve(e,"rgba"),i=A[0],n=A[1],a=A[2],r=A[3],s=Ce(e)||"auto";void 0===r&&(r=1),"auto"===s&&(s=r<1?"rgba":"rgb");var o="000000"+((i=ye(i))<<16|(n=ye(n))<<8|(a=ye(a))).toString(16);o=o.substr(o.length-6);var l="0"+ye(255*r).toString(16);switch(l=l.substr(l.length-2),s.toLowerCase()){case"rgba":return"#"+o+l;case"argb":return"#"+l+o;default:return"#"+o}},xe=/^#?([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/,Se=/^#?([A-Fa-f0-9]{8}|[A-Fa-f0-9]{4})$/,Te=function(e){if(e.match(xe)){4!==e.length&&7!==e.length||(e=e.substr(1)),3===e.length&&(e=(e=e.split(""))[0]+e[0]+e[1]+e[1]+e[2]+e[2]);var t=parseInt(e,16);return[t>>16,t>>8&255,255&t,1]}if(e.match(Se)){5!==e.length&&9!==e.length||(e=e.substr(1)),4===e.length&&(e=(e=e.split(""))[0]+e[0]+e[1]+e[1]+e[2]+e[2]+e[3]+e[3]);var A=parseInt(e,16);return[A>>24&255,A>>16&255,A>>8&255,Math.round((255&A)/255*100)/100]}throw new Error("unknown hex color: "+e)},Ie=E,ke=w,Ue=c.type,Qe=d,Oe=Fe;ke.prototype.hex=function(e){return Oe(this._rgb,e)},Ie.hex=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];return new(Function.prototype.bind.apply(ke,[null].concat(e,["hex"])))},Qe.format.hex=Te,Qe.autodetect.push({p:4,test:function(e){for(var t=[],A=arguments.length-1;A-- >0;)t[A]=arguments[A+1];if(!t.length&&"string"===Ue(e)&&[3,4,5,6,7,8,9].indexOf(e.length)>=0)return"hex"}});var Le=c.unpack,Me=c.TWOPI,Ne=Math.min,De=Math.sqrt,Re=Math.acos,He=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var A,i=Le(e,"rgb"),n=i[0],a=i[1],r=i[2],s=Ne(n/=255,a/=255,r/=255),o=(n+a+r)/3,l=o>0?1-s/o:0;return 0===l?A=NaN:(A=(n-a+(n-r))/2,A/=De((n-a)*(n-a)+(n-r)*(a-r)),A=Re(A),r>a&&(A=Me-A),A/=Me),[360*A,l,o]},Pe=c.unpack,Ve=c.limit,Ke=c.TWOPI,Ge=c.PITHIRD,We=Math.cos,ze=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var A,i,n,a=(e=Pe(e,"hsi"))[0],r=e[1],s=e[2];return isNaN(a)&&(a=0),isNaN(r)&&(r=0),a>360&&(a-=360),a<0&&(a+=360),(a/=360)<1/3?i=1-((n=(1-r)/3)+(A=(1+r*We(Ke*a)/We(Ge-Ke*a))/3)):a<2/3?n=1-((A=(1-r)/3)+(i=(1+r*We(Ke*(a-=1/3))/We(Ge-Ke*a))/3)):A=1-((i=(1-r)/3)+(n=(1+r*We(Ke*(a-=2/3))/We(Ge-Ke*a))/3)),[255*(A=Ve(s*A*3)),255*(i=Ve(s*i*3)),255*(n=Ve(s*n*3)),e.length>3?e[3]:1]},Xe=c.unpack,Ye=c.type,je=E,_e=w,Je=d,Ze=He;_e.prototype.hsi=function(){return Ze(this._rgb)},je.hsi=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];return new(Function.prototype.bind.apply(_e,[null].concat(e,["hsi"])))},Je.format.hsi=ze,Je.autodetect.push({p:2,test:function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];if(e=Xe(e,"hsi"),"array"===Ye(e)&&3===e.length)return"hsi"}});var qe=c.unpack,$e=c.type,et=E,tt=w,At=d,it=N;tt.prototype.hsl=function(){return it(this._rgb)},et.hsl=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];return new(Function.prototype.bind.apply(tt,[null].concat(e,["hsl"])))},At.format.hsl=z,At.autodetect.push({p:2,test:function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];if(e=qe(e,"hsl"),"array"===$e(e)&&3===e.length)return"hsl"}});var nt=c.unpack,at=Math.min,rt=Math.max,st=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var A,i,n,a=(e=nt(e,"rgb"))[0],r=e[1],s=e[2],o=at(a,r,s),l=rt(a,r,s),c=l-o;return n=l/255,0===l?(A=Number.NaN,i=0):(i=c/l,a===l&&(A=(r-s)/c),r===l&&(A=2+(s-a)/c),s===l&&(A=4+(a-r)/c),(A*=60)<0&&(A+=360)),[A,i,n]},ot=c.unpack,lt=Math.floor,ct=function(){for(var e,t,A,i,n,a,r=[],s=arguments.length;s--;)r[s]=arguments[s];var o,l,c,d=(r=ot(r,"hsv"))[0],h=r[1],u=r[2];if(u*=255,0===h)o=l=c=u;else{360===d&&(d=0),d>360&&(d-=360),d<0&&(d+=360);var g=lt(d/=60),p=d-g,m=u*(1-h),w=u*(1-h*p),f=u*(1-h*(1-p));switch(g){case 0:o=(e=[u,f,m])[0],l=e[1],c=e[2];break;case 1:o=(t=[w,u,m])[0],l=t[1],c=t[2];break;case 2:o=(A=[m,u,f])[0],l=A[1],c=A[2];break;case 3:o=(i=[m,w,u])[0],l=i[1],c=i[2];break;case 4:o=(n=[f,m,u])[0],l=n[1],c=n[2];break;case 5:o=(a=[u,m,w])[0],l=a[1],c=a[2]}}return[o,l,c,r.length>3?r[3]:1]},dt=c.unpack,ht=c.type,ut=E,gt=w,pt=d,mt=st;gt.prototype.hsv=function(){return mt(this._rgb)},ut.hsv=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];return new(Function.prototype.bind.apply(gt,[null].concat(e,["hsv"])))},pt.format.hsv=ct,pt.autodetect.push({p:2,test:function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];if(e=dt(e,"hsv"),"array"===ht(e)&&3===e.length)return"hsv"}});var wt={Kn:18,Xn:.95047,Yn:1,Zn:1.08883,t0:.137931034,t1:.206896552,t2:.12841855,t3:.008856452},ft=wt,Et=c.unpack,Bt=Math.pow,bt=function(e){return(e/=255)<=.04045?e/12.92:Bt((e+.055)/1.055,2.4)},vt=function(e){return e>ft.t3?Bt(e,1/3):e/ft.t2+ft.t0},Ct=function(e,t,A){return e=bt(e),t=bt(t),A=bt(A),[vt((.4124564*e+.3575761*t+.1804375*A)/ft.Xn),vt((.2126729*e+.7151522*t+.072175*A)/ft.Yn),vt((.0193339*e+.119192*t+.9503041*A)/ft.Zn)]},yt=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var A=Et(e,"rgb"),i=A[0],n=A[1],a=A[2],r=Ct(i,n,a),s=r[0],o=r[1],l=116*o-16;return[l<0?0:l,500*(s-o),200*(o-r[2])]},Ft=wt,xt=c.unpack,St=Math.pow,Tt=function(e){return 255*(e<=.00304?12.92*e:1.055*St(e,1/2.4)-.055)},It=function(e){return e>Ft.t1?e*e*e:Ft.t2*(e-Ft.t0)},kt=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var A,i,n,a=(e=xt(e,"lab"))[0],r=e[1],s=e[2];return i=(a+16)/116,A=isNaN(r)?i:i+r/500,n=isNaN(s)?i:i-s/200,i=Ft.Yn*It(i),A=Ft.Xn*It(A),n=Ft.Zn*It(n),[Tt(3.2404542*A-1.5371385*i-.4985314*n),Tt(-.969266*A+1.8760108*i+.041556*n),Tt(.0556434*A-.2040259*i+1.0572252*n),e.length>3?e[3]:1]},Ut=c.unpack,Qt=c.type,Ot=E,Lt=w,Mt=d,Nt=yt;Lt.prototype.lab=function(){return Nt(this._rgb)},Ot.lab=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];return new(Function.prototype.bind.apply(Lt,[null].concat(e,["lab"])))},Mt.format.lab=kt,Mt.autodetect.push({p:2,test:function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];if(e=Ut(e,"lab"),"array"===Qt(e)&&3===e.length)return"lab"}});var Dt=c.unpack,Rt=c.RAD2DEG,Ht=Math.sqrt,Pt=Math.atan2,Vt=Math.round,Kt=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var A=Dt(e,"lab"),i=A[0],n=A[1],a=A[2],r=Ht(n*n+a*a),s=(Pt(a,n)*Rt+360)%360;return 0===Vt(1e4*r)&&(s=Number.NaN),[i,r,s]},Gt=c.unpack,Wt=yt,zt=Kt,Xt=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var A=Gt(e,"rgb"),i=A[0],n=A[1],a=A[2],r=Wt(i,n,a),s=r[0],o=r[1],l=r[2];return zt(s,o,l)},Yt=c.unpack,jt=c.DEG2RAD,_t=Math.sin,Jt=Math.cos,Zt=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var A=Yt(e,"lch"),i=A[0],n=A[1],a=A[2];return isNaN(a)&&(a=0),[i,Jt(a*=jt)*n,_t(a)*n]},qt=c.unpack,$t=Zt,eA=kt,tA=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var A=(e=qt(e,"lch"))[0],i=e[1],n=e[2],a=$t(A,i,n),r=a[0],s=a[1],o=a[2],l=eA(r,s,o);return[l[0],l[1],l[2],e.length>3?e[3]:1]},AA=c.unpack,iA=tA,nA=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var A=AA(e,"hcl").reverse();return iA.apply(void 0,A)},aA=c.unpack,rA=c.type,sA=E,oA=w,lA=d,cA=Xt;oA.prototype.lch=function(){return cA(this._rgb)},oA.prototype.hcl=function(){return cA(this._rgb).reverse()},sA.lch=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];return new(Function.prototype.bind.apply(oA,[null].concat(e,["lch"])))},sA.hcl=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];return new(Function.prototype.bind.apply(oA,[null].concat(e,["hcl"])))},lA.format.lch=tA,lA.format.hcl=nA,["lch","hcl"].forEach((function(e){return lA.autodetect.push({p:2,test:function(){for(var t=[],A=arguments.length;A--;)t[A]=arguments[A];if(t=aA(t,e),"array"===rA(t)&&3===t.length)return e}})}));var dA={aliceblue:"#f0f8ff",antiquewhite:"#faebd7",aqua:"#00ffff",aquamarine:"#7fffd4",azure:"#f0ffff",beige:"#f5f5dc",bisque:"#ffe4c4",black:"#000000",blanchedalmond:"#ffebcd",blue:"#0000ff",blueviolet:"#8a2be2",brown:"#a52a2a",burlywood:"#deb887",cadetblue:"#5f9ea0",chartreuse:"#7fff00",chocolate:"#d2691e",coral:"#ff7f50",cornflower:"#6495ed",cornflowerblue:"#6495ed",cornsilk:"#fff8dc",crimson:"#dc143c",cyan:"#00ffff",darkblue:"#00008b",darkcyan:"#008b8b",darkgoldenrod:"#b8860b",darkgray:"#a9a9a9",darkgreen:"#006400",darkgrey:"#a9a9a9",darkkhaki:"#bdb76b",darkmagenta:"#8b008b",darkolivegreen:"#556b2f",darkorange:"#ff8c00",darkorchid:"#9932cc",darkred:"#8b0000",darksalmon:"#e9967a",darkseagreen:"#8fbc8f",darkslateblue:"#483d8b",darkslategray:"#2f4f4f",darkslategrey:"#2f4f4f",darkturquoise:"#00ced1",darkviolet:"#9400d3",deeppink:"#ff1493",deepskyblue:"#00bfff",dimgray:"#696969",dimgrey:"#696969",dodgerblue:"#1e90ff",firebrick:"#b22222",floralwhite:"#fffaf0",forestgreen:"#228b22",fuchsia:"#ff00ff",gainsboro:"#dcdcdc",ghostwhite:"#f8f8ff",gold:"#ffd700",goldenrod:"#daa520",gray:"#808080",green:"#008000",greenyellow:"#adff2f",grey:"#808080",honeydew:"#f0fff0",hotpink:"#ff69b4",indianred:"#cd5c5c",indigo:"#4b0082",ivory:"#fffff0",khaki:"#f0e68c",laserlemon:"#ffff54",lavender:"#e6e6fa",lavenderblush:"#fff0f5",lawngreen:"#7cfc00",lemonchiffon:"#fffacd",lightblue:"#add8e6",lightcoral:"#f08080",lightcyan:"#e0ffff",lightgoldenrod:"#fafad2",lightgoldenrodyellow:"#fafad2",lightgray:"#d3d3d3",lightgreen:"#90ee90",lightgrey:"#d3d3d3",lightpink:"#ffb6c1",lightsalmon:"#ffa07a",lightseagreen:"#20b2aa",lightskyblue:"#87cefa",lightslategray:"#778899",lightslategrey:"#778899",lightsteelblue:"#b0c4de",lightyellow:"#ffffe0",lime:"#00ff00",limegreen:"#32cd32",linen:"#faf0e6",magenta:"#ff00ff",maroon:"#800000",maroon2:"#7f0000",maroon3:"#b03060",mediumaquamarine:"#66cdaa",mediumblue:"#0000cd",mediumorchid:"#ba55d3",mediumpurple:"#9370db",mediumseagreen:"#3cb371",mediumslateblue:"#7b68ee",mediumspringgreen:"#00fa9a",mediumturquoise:"#48d1cc",mediumvioletred:"#c71585",midnightblue:"#191970",mintcream:"#f5fffa",mistyrose:"#ffe4e1",moccasin:"#ffe4b5",navajowhite:"#ffdead",navy:"#000080",oldlace:"#fdf5e6",olive:"#808000",olivedrab:"#6b8e23",orange:"#ffa500",orangered:"#ff4500",orchid:"#da70d6",palegoldenrod:"#eee8aa",palegreen:"#98fb98",paleturquoise:"#afeeee",palevioletred:"#db7093",papayawhip:"#ffefd5",peachpuff:"#ffdab9",peru:"#cd853f",pink:"#ffc0cb",plum:"#dda0dd",powderblue:"#b0e0e6",purple:"#800080",purple2:"#7f007f",purple3:"#a020f0",rebeccapurple:"#663399",red:"#ff0000",rosybrown:"#bc8f8f",royalblue:"#4169e1",saddlebrown:"#8b4513",salmon:"#fa8072",sandybrown:"#f4a460",seagreen:"#2e8b57",seashell:"#fff5ee",sienna:"#a0522d",silver:"#c0c0c0",skyblue:"#87ceeb",slateblue:"#6a5acd",slategray:"#708090",slategrey:"#708090",snow:"#fffafa",springgreen:"#00ff7f",steelblue:"#4682b4",tan:"#d2b48c",teal:"#008080",thistle:"#d8bfd8",tomato:"#ff6347",turquoise:"#40e0d0",violet:"#ee82ee",wheat:"#f5deb3",white:"#ffffff",whitesmoke:"#f5f5f5",yellow:"#ffff00",yellowgreen:"#9acd32"},hA=d,uA=c.type,gA=dA,pA=Te,mA=Fe;w.prototype.name=function(){for(var e=mA(this._rgb,"rgb"),t=0,A=Object.keys(gA);t0;)t[A]=arguments[A+1];if(!t.length&&"string"===uA(e)&&gA[e.toLowerCase()])return"named"}});var wA=c.unpack,fA=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var A=wA(e,"rgb");return(A[0]<<16)+(A[1]<<8)+A[2]},EA=c.type,BA=function(e){if("number"==EA(e)&&e>=0&&e<=16777215)return[e>>16,e>>8&255,255&e,1];throw new Error("unknown num color: "+e)},bA=E,vA=w,CA=d,yA=c.type,FA=fA;vA.prototype.num=function(){return FA(this._rgb)},bA.num=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];return new(Function.prototype.bind.apply(vA,[null].concat(e,["num"])))},CA.format.num=BA,CA.autodetect.push({p:5,test:function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];if(1===e.length&&"number"===yA(e[0])&&e[0]>=0&&e[0]<=16777215)return"num"}});var xA=E,SA=w,TA=d,IA=c.unpack,kA=c.type,UA=Math.round;SA.prototype.rgb=function(e){return void 0===e&&(e=!0),!1===e?this._rgb.slice(0,3):this._rgb.slice(0,3).map(UA)},SA.prototype.rgba=function(e){return void 0===e&&(e=!0),this._rgb.slice(0,4).map((function(t,A){return A<3?!1===e?t:UA(t):t}))},xA.rgb=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];return new(Function.prototype.bind.apply(SA,[null].concat(e,["rgb"])))},TA.format.rgb=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var A=IA(e,"rgba");return void 0===A[3]&&(A[3]=1),A},TA.autodetect.push({p:3,test:function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];if(e=IA(e,"rgba"),"array"===kA(e)&&(3===e.length||4===e.length&&"number"==kA(e[3])&&e[3]>=0&&e[3]<=1))return"rgb"}});var QA=Math.log,OA=function(e){var t,A,i,n=e/100;return n<66?(t=255,A=n<6?0:-155.25485562709179-.44596950469579133*(A=n-2)+104.49216199393888*QA(A),i=n<20?0:.8274096064007395*(i=n-10)-254.76935184120902+115.67994401066147*QA(i)):(t=351.97690566805693+.114206453784165*(t=n-55)-40.25366309332127*QA(t),A=325.4494125711974+.07943456536662342*(A=n-50)-28.0852963507957*QA(A),i=255),[t,A,i,1]},LA=OA,MA=c.unpack,NA=Math.round,DA=E,RA=w,HA=d,PA=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];for(var A,i=MA(e,"rgb"),n=i[0],a=i[2],r=1e3,s=4e4,o=.4;s-r>o;){var l=LA(A=.5*(s+r));l[2]/l[0]>=a/n?s=A:r=A}return NA(A)};RA.prototype.temp=RA.prototype.kelvin=RA.prototype.temperature=function(){return PA(this._rgb)},DA.temp=DA.kelvin=DA.temperature=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];return new(Function.prototype.bind.apply(RA,[null].concat(e,["temp"])))},HA.format.temp=HA.format.kelvin=HA.format.temperature=OA;var VA=c.unpack,KA=Math.cbrt,GA=Math.pow,WA=Math.sign,zA=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var A=VA(e,"rgb"),i=A[0],n=A[1],a=A[2],r=[XA(i/255),XA(n/255),XA(a/255)],s=r[0],o=r[1],l=r[2],c=KA(.4122214708*s+.5363325363*o+.0514459929*l),d=KA(.2119034982*s+.6806995451*o+.1073969566*l),h=KA(.0883024619*s+.2817188376*o+.6299787005*l);return[.2104542553*c+.793617785*d-.0040720468*h,1.9779984951*c-2.428592205*d+.4505937099*h,.0259040371*c+.7827717662*d-.808675766*h]};function XA(e){var t=Math.abs(e);return t<.04045?e/12.92:(WA(e)||1)*GA((t+.055)/1.055,2.4)}var YA=c.unpack,jA=Math.pow,_A=Math.sign,JA=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var A=(e=YA(e,"lab"))[0],i=e[1],n=e[2],a=jA(A+.3963377774*i+.2158037573*n,3),r=jA(A-.1055613458*i-.0638541728*n,3),s=jA(A-.0894841775*i-1.291485548*n,3);return[255*ZA(4.0767416621*a-3.3077115913*r+.2309699292*s),255*ZA(-1.2684380046*a+2.6097574011*r-.3413193965*s),255*ZA(-.0041960863*a-.7034186147*r+1.707614701*s),e.length>3?e[3]:1]};function ZA(e){var t=Math.abs(e);return t>.0031308?(_A(e)||1)*(1.055*jA(t,1/2.4)-.055):12.92*e}var qA=c.unpack,$A=c.type,ei=E,ti=w,Ai=d,ii=zA;ti.prototype.oklab=function(){return ii(this._rgb)},ei.oklab=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];return new(Function.prototype.bind.apply(ti,[null].concat(e,["oklab"])))},Ai.format.oklab=JA,Ai.autodetect.push({p:3,test:function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];if(e=qA(e,"oklab"),"array"===$A(e)&&3===e.length)return"oklab"}});var ni=c.unpack,ai=zA,ri=Kt,si=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var A=ni(e,"rgb"),i=A[0],n=A[1],a=A[2],r=ai(i,n,a),s=r[0],o=r[1],l=r[2];return ri(s,o,l)},oi=c.unpack,li=Zt,ci=JA,di=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var A=(e=oi(e,"lch"))[0],i=e[1],n=e[2],a=li(A,i,n),r=a[0],s=a[1],o=a[2],l=ci(r,s,o);return[l[0],l[1],l[2],e.length>3?e[3]:1]},hi=c.unpack,ui=c.type,gi=E,pi=w,mi=d,wi=si;pi.prototype.oklch=function(){return wi(this._rgb)},gi.oklch=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];return new(Function.prototype.bind.apply(pi,[null].concat(e,["oklch"])))},mi.format.oklch=di,mi.autodetect.push({p:3,test:function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];if(e=hi(e,"oklch"),"array"===ui(e)&&3===e.length)return"oklch"}});var fi=w,Ei=c.type;fi.prototype.alpha=function(e,t){return void 0===t&&(t=!1),void 0!==e&&"number"===Ei(e)?t?(this._rgb[3]=e,this):new fi([this._rgb[0],this._rgb[1],this._rgb[2],e],"rgb"):this._rgb[3]},w.prototype.clipped=function(){return this._rgb._clipped||!1};var Bi=w,bi=wt;Bi.prototype.darken=function(e){void 0===e&&(e=1);var t=this.lab();return t[0]-=bi.Kn*e,new Bi(t,"lab").alpha(this.alpha(),!0)},Bi.prototype.brighten=function(e){return void 0===e&&(e=1),this.darken(-e)},Bi.prototype.darker=Bi.prototype.darken,Bi.prototype.brighter=Bi.prototype.brighten,w.prototype.get=function(e){var t=e.split("."),A=t[0],i=t[1],n=this[A]();if(i){var a=A.indexOf(i)-("ok"===A.substr(0,2)?2:0);if(a>-1)return n[a];throw new Error("unknown channel "+i+" in mode "+A)}return n};var vi=w,Ci=c.type,yi=Math.pow;vi.prototype.luminance=function(e){if(void 0!==e&&"number"===Ci(e)){if(0===e)return new vi([0,0,0,this._rgb[3]],"rgb");if(1===e)return new vi([255,255,255,this._rgb[3]],"rgb");var t=this.luminance(),A=20,i=function(t,n){var a=t.interpolate(n,.5,"rgb"),r=a.luminance();return Math.abs(e-r)<1e-7||!A--?a:r>e?i(t,a):i(a,n)},n=(t>e?i(new vi([0,0,0]),this):i(this,new vi([255,255,255]))).rgb();return new vi(n.concat([this._rgb[3]]))}return Fi.apply(void 0,this._rgb.slice(0,3))};var Fi=function(e,t,A){return.2126*(e=xi(e))+.7152*(t=xi(t))+.0722*xi(A)},xi=function(e){return(e/=255)<=.03928?e/12.92:yi((e+.055)/1.055,2.4)},Si={},Ti=w,Ii=c.type,ki=Si,Ui=function(e,t,A){void 0===A&&(A=.5);for(var i=[],n=arguments.length-3;n-- >0;)i[n]=arguments[n+3];var a=i[0]||"lrgb";if(ki[a]||i.length||(a=Object.keys(ki)[0]),!ki[a])throw new Error("interpolation mode "+a+" is not defined");return"object"!==Ii(e)&&(e=new Ti(e)),"object"!==Ii(t)&&(t=new Ti(t)),ki[a](e,t,A).alpha(e.alpha()+A*(t.alpha()-e.alpha()))},Qi=w,Oi=Ui;Qi.prototype.mix=Qi.prototype.interpolate=function(e,t){void 0===t&&(t=.5);for(var A=[],i=arguments.length-2;i-- >0;)A[i]=arguments[i+2];return Oi.apply(void 0,[this,e,t].concat(A))};var Li=w;Li.prototype.premultiply=function(e){void 0===e&&(e=!1);var t=this._rgb,A=t[3];return e?(this._rgb=[t[0]*A,t[1]*A,t[2]*A,A],this):new Li([t[0]*A,t[1]*A,t[2]*A,A],"rgb")};var Mi=w,Ni=wt;Mi.prototype.saturate=function(e){void 0===e&&(e=1);var t=this.lch();return t[1]+=Ni.Kn*e,t[1]<0&&(t[1]=0),new Mi(t,"lch").alpha(this.alpha(),!0)},Mi.prototype.desaturate=function(e){return void 0===e&&(e=1),this.saturate(-e)};var Di=w,Ri=c.type;Di.prototype.set=function(e,t,A){void 0===A&&(A=!1);var i=e.split("."),n=i[0],a=i[1],r=this[n]();if(a){var s=n.indexOf(a)-("ok"===n.substr(0,2)?2:0);if(s>-1){if("string"==Ri(t))switch(t.charAt(0)){case"+":case"-":r[s]+=+t;break;case"*":r[s]*=+t.substr(1);break;case"/":r[s]/=+t.substr(1);break;default:r[s]=+t}else{if("number"!==Ri(t))throw new Error("unsupported value for Color.set");r[s]=t}var o=new Di(r,n);return A?(this._rgb=o._rgb,this):o}throw new Error("unknown channel "+a+" in mode "+n)}return r};var Hi=w;Si.rgb=function(e,t,A){var i=e._rgb,n=t._rgb;return new Hi(i[0]+A*(n[0]-i[0]),i[1]+A*(n[1]-i[1]),i[2]+A*(n[2]-i[2]),"rgb")};var Pi=w,Vi=Math.sqrt,Ki=Math.pow;Si.lrgb=function(e,t,A){var i=e._rgb,n=i[0],a=i[1],r=i[2],s=t._rgb,o=s[0],l=s[1],c=s[2];return new Pi(Vi(Ki(n,2)*(1-A)+Ki(o,2)*A),Vi(Ki(a,2)*(1-A)+Ki(l,2)*A),Vi(Ki(r,2)*(1-A)+Ki(c,2)*A),"rgb")};var Gi=w;Si.lab=function(e,t,A){var i=e.lab(),n=t.lab();return new Gi(i[0]+A*(n[0]-i[0]),i[1]+A*(n[1]-i[1]),i[2]+A*(n[2]-i[2]),"lab")};var Wi=w,zi=function(e,t,A,i){var n,a,r,s,o,l,c,d,h,u,g,p,m;return"hsl"===i?(r=e.hsl(),s=t.hsl()):"hsv"===i?(r=e.hsv(),s=t.hsv()):"hcg"===i?(r=e.hcg(),s=t.hcg()):"hsi"===i?(r=e.hsi(),s=t.hsi()):"lch"===i||"hcl"===i?(i="hcl",r=e.hcl(),s=t.hcl()):"oklch"===i&&(r=e.oklch().reverse(),s=t.oklch().reverse()),"h"!==i.substr(0,1)&&"oklch"!==i||(o=(n=r)[0],c=n[1],h=n[2],l=(a=s)[0],d=a[1],u=a[2]),isNaN(o)||isNaN(l)?isNaN(o)?isNaN(l)?p=Number.NaN:(p=l,1!=h&&0!=h||"hsv"==i||(g=d)):(p=o,1!=u&&0!=u||"hsv"==i||(g=c)):p=o+A*(l>o&&l-o>180?l-(o+360):l180?l+360-o:l-o),void 0===g&&(g=c+A*(d-c)),m=h+A*(u-h),new Wi("oklch"===i?[m,g,p]:[p,g,m],i)},Xi=zi,Yi=function(e,t,A){return Xi(e,t,A,"lch")};Si.lch=Yi,Si.hcl=Yi;var ji=w;Si.num=function(e,t,A){var i=e.num(),n=t.num();return new ji(i+A*(n-i),"num")};var _i=zi;Si.hcg=function(e,t,A){return _i(e,t,A,"hcg")};var Ji=zi;Si.hsi=function(e,t,A){return Ji(e,t,A,"hsi")};var Zi=zi;Si.hsl=function(e,t,A){return Zi(e,t,A,"hsl")};var qi=zi;Si.hsv=function(e,t,A){return qi(e,t,A,"hsv")};var $i=w;Si.oklab=function(e,t,A){var i=e.oklab(),n=t.oklab();return new $i(i[0]+A*(n[0]-i[0]),i[1]+A*(n[1]-i[1]),i[2]+A*(n[2]-i[2]),"oklab")};var en=zi;Si.oklch=function(e,t,A){return en(e,t,A,"oklch")};var tn=w,An=c.clip_rgb,nn=Math.pow,an=Math.sqrt,rn=Math.PI,sn=Math.cos,on=Math.sin,ln=Math.atan2,cn=function(e,t){for(var A=e.length,i=[0,0,0,0],n=0;n.9999999&&(i[3]=1),new tn(An(i))},dn=E,hn=c.type,un=Math.pow,gn=function(e){var t="rgb",A=dn("#ccc"),i=0,n=[0,1],a=[],r=[0,0],s=!1,o=[],l=!1,c=0,d=1,h=!1,u={},g=!0,p=1,m=function(e){if((e=e||["#fff","#000"])&&"string"===hn(e)&&dn.brewer&&dn.brewer[e.toLowerCase()]&&(e=dn.brewer[e.toLowerCase()]),"array"===hn(e)){1===e.length&&(e=[e[0],e[0]]),e=e.slice(0);for(var t=0;t2?function(e){if(null!=s){for(var t=s.length-1,A=0;A=s[A];)A++;return A-1}return 0}(e)/(s.length-2):d!==c?(e-c)/(d-c):1,l=f(l),i||(l=w(l)),1!==p&&(l=un(l,p)),l=r[0]+l*(1-r[0]-r[1]),l=Math.min(1,Math.max(0,l));var h=Math.floor(1e4*l);if(g&&u[h])n=u[h];else{if("array"===hn(o))for(var m=0;m=E&&m===a.length-1){n=o[m];break}if(l>E&&l2){var l=e.map((function(t,A){return A/(e.length-1)})),h=e.map((function(e){return(e-c)/(d-c)}));h.every((function(e,t){return l[t]===e}))||(f=function(e){if(e<=0||e>=1)return e;for(var t=0;e>=h[t+1];)t++;var A=(e-h[t])/(h[t+1]-h[t]);return l[t]+A*(l[t+1]-l[t])})}}return n=[c,d],b},b.mode=function(e){return arguments.length?(t=e,B(),b):t},b.range=function(e,t){return m(e),b},b.out=function(e){return l=e,b},b.spread=function(e){return arguments.length?(i=e,b):i},b.correctLightness=function(e){return null==e&&(e=!0),h=e,B(),w=h?function(e){for(var t=E(0,!0).lab()[0],A=E(1,!0).lab()[0],i=t>A,n=E(e,!0).lab()[0],a=t+(A-t)*e,r=n-a,s=0,o=1,l=20;Math.abs(r)>.01&&l-- >0;)i&&(r*=-1),r<0?(s=e,e+=.5*(o-e)):(o=e,e+=.5*(s-e)),r=(n=E(e,!0).lab()[0])-a;return e}:function(e){return e},b},b.padding=function(e){return null!=e?("number"===hn(e)&&(e=[e,e]),r=e,b):r},b.colors=function(t,A){arguments.length<2&&(A="hex");var i=[];if(0===arguments.length)i=o.slice(0);else if(1===t)i=[b(.5)];else if(t>1){var a=n[0],r=n[1]-a;i=pn(0,t,!1).map((function(e){return b(a+e/(t-1)*r)}))}else{e=[];var l=[];if(s&&s.length>2)for(var c=1,d=s.length,h=1<=d;h?cd;h?c++:c--)l.push(.5*(s[c-1]+s[c]));else l=n;i=l.map((function(e){return b(e)}))}return dn[A]&&(i=i.map((function(e){return e[A]()}))),i},b.cache=function(e){return null!=e?(g=e,b):g},b.gamma=function(e){return null!=e?(p=e,b):p},b.nodata=function(e){return null!=e?(A=dn(e),b):A},b};function pn(e,t,A){for(var i=[],n=ea;n?r++:r--)i.push(r);return i}var mn=w,wn=gn,fn=E,En=function(e,t,A){if(!En[A])throw new Error("unknown blend mode "+A);return En[A](e,t)},Bn=function(e){return function(t,A){var i=fn(A).rgb(),n=fn(t).rgb();return fn.rgb(e(i,n))}},bn=function(e){return function(t,A){var i=[];return i[0]=e(t[0],A[0]),i[1]=e(t[1],A[1]),i[2]=e(t[2],A[2]),i}};En.normal=Bn(bn((function(e){return e}))),En.multiply=Bn(bn((function(e,t){return e*t/255}))),En.screen=Bn(bn((function(e,t){return 255*(1-(1-e/255)*(1-t/255))}))),En.overlay=Bn(bn((function(e,t){return t<128?2*e*t/255:255*(1-2*(1-e/255)*(1-t/255))}))),En.darken=Bn(bn((function(e,t){return e>t?t:e}))),En.lighten=Bn(bn((function(e,t){return e>t?e:t}))),En.dodge=Bn(bn((function(e,t){return 255===e||(e=t/255*255/(1-e/255))>255?255:e}))),En.burn=Bn(bn((function(e,t){return 255*(1-(1-t/255)/(e/255))})));for(var vn=En,Cn=c.type,yn=c.clip_rgb,Fn=c.TWOPI,xn=Math.pow,Sn=Math.sin,Tn=Math.cos,In=E,kn=w,Un=Math.floor,Qn=Math.random,On=r,Ln=Math.log,Mn=Math.pow,Nn=Math.floor,Dn=Math.abs,Rn=function(e,t){void 0===t&&(t=null);var A={min:Number.MAX_VALUE,max:-1*Number.MAX_VALUE,sum:0,values:[],count:0};return"object"===On(e)&&(e=Object.values(e)),e.forEach((function(e){t&&"object"===On(e)&&(e=e[t]),null==e||isNaN(e)||(A.values.push(e),A.sum+=e,eA.max&&(A.max=e),A.count+=1)})),A.domain=[A.min,A.max],A.limits=function(e,t){return Hn(A,e,t)},A},Hn=function(e,t,A){void 0===t&&(t="equal"),void 0===A&&(A=7),"array"==On(e)&&(e=Rn(e));var i=e.min,n=e.max,a=e.values.sort((function(e,t){return e-t}));if(1===A)return[i,n];var r=[];if("c"===t.substr(0,1)&&(r.push(i),r.push(n)),"e"===t.substr(0,1)){r.push(i);for(var s=1;s 0");var o=Math.LOG10E*Ln(i),l=Math.LOG10E*Ln(n);r.push(i);for(var c=1;c200&&(E=!1)}for(var M={},N=0;N=360;)g-=360;r[u]=g}else r[u]=r[u]/s[u];return h/=i,new tn(r,t).alpha(h>.99999?1:h,!0)},la.bezier=function(e){var t=function(e){var t,A,i,n,a,r,s;if(e=e.map((function(e){return new mn(e)})),2===e.length)t=e.map((function(e){return e.lab()})),a=t[0],r=t[1],n=function(e){var t=[0,1,2].map((function(t){return a[t]+e*(r[t]-a[t])}));return new mn(t,"lab")};else if(3===e.length)A=e.map((function(e){return e.lab()})),a=A[0],r=A[1],s=A[2],n=function(e){var t=[0,1,2].map((function(t){return(1-e)*(1-e)*a[t]+2*(1-e)*e*r[t]+e*e*s[t]}));return new mn(t,"lab")};else if(4===e.length){var o;i=e.map((function(e){return e.lab()})),a=i[0],r=i[1],s=i[2],o=i[3],n=function(e){var t=[0,1,2].map((function(t){return(1-e)*(1-e)*(1-e)*a[t]+3*(1-e)*(1-e)*e*r[t]+3*(1-e)*e*e*s[t]+e*e*e*o[t]}));return new mn(t,"lab")}}else{if(!(e.length>=5))throw new RangeError("No point in running bezier with only one color.");var l,c,d;l=e.map((function(e){return e.lab()})),d=e.length-1,c=function(e){for(var t=[1,1],A=1;Ai?(A+.05)/(i+.05):(i+.05)/(A+.05)},la.deltaE=function(e,t,A,i,n){void 0===A&&(A=1),void 0===i&&(i=1),void 0===n&&(n=1);var a=function(e){return 360*e/(2*qn)},r=function(e){return 2*qn*e/360};e=new Kn(e),t=new Kn(t);var s=Array.from(e.lab()),o=s[0],l=s[1],c=s[2],d=Array.from(t.lab()),h=d[0],u=d[1],g=d[2],p=(o+h)/2,m=(Gn(Wn(l,2)+Wn(c,2))+Gn(Wn(u,2)+Wn(g,2)))/2,w=.5*(1-Gn(Wn(m,7)/(Wn(m,7)+Wn(25,7)))),f=l*(1+w),E=u*(1+w),B=Gn(Wn(f,2)+Wn(c,2)),b=Gn(Wn(E,2)+Wn(g,2)),v=(B+b)/2,C=a(Yn(c,f)),y=a(Yn(g,E)),F=C>=0?C:C+360,x=y>=0?y:y+360,S=jn(F-x)>180?(F+x+360)/2:(F+x)/2,T=1-.17*_n(r(S-30))+.24*_n(r(2*S))+.32*_n(r(3*S+6))-.2*_n(r(4*S-63)),I=x-F;I=jn(I)<=180?I:x<=F?I+360:I-360,I=2*Gn(B*b)*Jn(r(I)/2);var k=h-o,U=b-B,Q=1+.015*Wn(p-50,2)/Gn(20+Wn(p-50,2)),O=1+.045*v,L=1+.015*v*T,M=30*Zn(-Wn((S-275)/25,2)),N=-2*Gn(Wn(v,7)/(Wn(v,7)+Wn(25,7)))*Jn(2*r(M)),D=Gn(Wn(k/(A*Q),2)+Wn(U/(i*O),2)+Wn(I/(n*L),2)+N*(U/(i*O))*(I/(n*L)));return Xn(0,zn(100,D))},la.distance=function(e,t,A){void 0===A&&(A="lab"),e=new $n(e),t=new $n(t);var i=e.get(A),n=t.get(A),a=0;for(var r in i){var s=(i[r]||0)-(n[r]||0);a+=s*s}return Math.sqrt(a)},la.limits=Pn.limits,la.valid=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];try{return new(Function.prototype.bind.apply(ea,[null].concat(e))),!0}catch(e){return!1}},la.scales=ia,la.colors=dA,la.brewer=oa,la}();var chroma=chromaExports;function hexWithAlpha(e,t){return chroma(e).alpha(t).css()}function has(e,t){return e.hasAttribute(t)}function get(e,t,A){return e.getAttribute(t)||A||""}function getNum(e,t,A){const i=Number(get(e,t));return Number.isNaN(i)?A||0:i}const attrHandlers={stroke:({el:e,exVals:t})=>{const A=get(e,"stroke");t.strokeColor=has(e,"stroke-opacity")?hexWithAlpha(A,getNum(e,"stroke-opacity")):A},"stroke-opacity":({el:e,exVals:t})=>{t.strokeColor=hexWithAlpha(get(e,"stroke","#000000"),getNum(e,"stroke-opacity"))},"stroke-width":({el:e,exVals:t})=>{t.strokeWidth=getNum(e,"stroke-width")},fill:({el:e,exVals:t})=>{const A=get(e,"fill");t.backgroundColor="none"===A?"#00000000":A},"fill-opacity":({el:e,exVals:t})=>{t.backgroundColor=hexWithAlpha(get(e,"fill","#000000"),getNum(e,"fill-opacity"))},opacity:({el:e,exVals:t})=>{t.opacity=getNum(e,"opacity",100)}};function presAttrsToElementValues(e){return[...e.attributes].reduce(((t,A)=>{const i=A.name;return Object.keys(attrHandlers).includes(i)&&attrHandlers[i]({el:e,exVals:t}),t}),{})}function filterAttrsToElementValues(e){const t={};return has(e,"x")&&(t.x=getNum(e,"x")),has(e,"y")&&(t.y=getNum(e,"y")),has(e,"width")&&(t.width=getNum(e,"width")),has(e,"height")&&(t.height=getNum(e,"height")),t}function pointsAttrToPoints(e){let t=[];return has(e,"points")&&(t=get(e,"points").split(" ").map((e=>e.split(",").map(parseFloat)))),t}function getGroupAttrs(e){return e.reduce(((e,{element:t})=>{const A=presAttrsToElementValues(t);return Object.assign(Object.assign({},e),A)}),{})}class Group{constructor(e){this.id=randomId(),this.element=e}}function createExElement(){return{id:randomId(),x:0,y:0,strokeColor:"#000000",backgroundColor:"#000000",fillStyle:"solid",strokeWidth:1,strokeStyle:"solid",roundness:null,roughness:0,opacity:100,width:0,height:0,angle:0,seed:Math.floor(random.next()*2**31),version:0,versionNonce:0,isDeleted:!1,groupIds:[],boundElementIds:null}}function createExRect(){return Object.assign(Object.assign({},createExElement()),{type:"rectangle"})}function createExLine(){return Object.assign(Object.assign({},createExElement()),{type:"line",points:[]})}function createExEllipse(){return Object.assign(Object.assign({},createExElement()),{type:"ellipse"})}function createExDraw(){return Object.assign(Object.assign({},createExElement()),{type:"line",points:[]})}const transformFunctions={matrix:"matrix",matrix3d:"matrix3d",perspective:"perspective",rotate:"rotate",rotate3d:"rotate3d",rotateX:"rotateX",rotateY:"rotateY",rotateZ:"rotateZ",scale:"scale",scale3d:"scale3d",scaleX:"scaleX",scaleY:"scaleY",scaleZ:"scaleZ",skew:"skew",skewX:"skewX",skewY:"skewY",translate:"translate",translate3d:"translate3d",translateX:"translateX",translateY:"translateY",translateZ:"translateZ"},transformFunctionsArr=Object.keys(transformFunctions),defaultUnits={matrix:"",matrix3d:"",perspective:"perspective",rotate:"deg",rotate3d:"deg",rotateX:"deg",rotateY:"deg",rotateZ:"deg",scale:"",scale3d:"",scaleX:"",scaleY:"",scaleZ:"",skew:"skew",skewX:"deg",skewY:"deg",translate:"px",translate3d:"px",translateX:"px",translateY:"px",translateZ:"px"},svgTransformToCSSTransform=e=>{const t=e.match(/(\w+)\(([^)]*)\)/g);if(!t)return"";const A=t.map((e=>{const t=e.split("(")[0];if(!t)throw new Error("Unable to find transform name");if(!transformFunctionsArr.includes(t))throw new Error(`transform function name "${t}" is not valid`);const A=e.match(/([-+]?[0-9]*\.?[0-9]+)([a-z])*/g);if(!A)return{type:t,values:[]};let i=A.map((e=>{const[A,i]=e.matchAll(/([-+]?[0-9]*\.?[0-9]+)|([a-z])*/g);return{unit:i[0]||defaultUnits[t],value:A[0]}}));return i&&"rotate"===t&&(null==i?void 0:i.length)>1&&(i=[i[0]]),{type:t,values:i}}));return A.map((({type:e,values:t})=>`${e}(${t.map((({unit:e,value:t})=>`${t}${e}`)).join(", ")})`)).join(" ")};function getElementMatrix(e){if(e.hasAttribute("transform")){const t=new DOMMatrix(svgTransformToCSSTransform(e.getAttribute("transform")||""));return multiply(create$1(),create$1(),t.toFloat32Array())}return create$1()}function getTransformMatrix(e,t){return t.map((({element:e})=>getElementMatrix(e))).concat([getElementMatrix(e)]).reduce(((e,t)=>multiply(e,e,t)),create$1())}function transformPoints(e,t){return e.map((([e,A])=>{const[i,n]=transformMat4(create(),fromValues(e,A,1),t);return[i,n]}))}function distance(e,t){return Math.sqrt(distanceSq(e,t))}function distanceSq(e,t){return Math.pow(e[0]-t[0],2)+Math.pow(e[1]-t[1],2)}function distanceToSegmentSq(e,t,A){const i=distanceSq(t,A);if(0===i)return distanceSq(e,t);let n=((e[0]-t[0])*(A[0]-t[0])+(e[1]-t[1])*(A[1]-t[1]))/i;return n=Math.max(0,Math.min(1,n)),distanceSq(e,lerp(t,A,n))}function lerp(e,t,A){return[e[0]+(t[0]-e[0])*A,e[1]+(t[1]-e[1])*A]}function flatness(e,t){const A=e[t+0],i=e[t+1],n=e[t+2],a=e[t+3];let r=3*i[0]-2*A[0]-a[0];r*=r;let s=3*i[1]-2*A[1]-a[1];s*=s;let o=3*n[0]-2*a[0]-A[0];o*=o;let l=3*n[1]-2*a[1]-A[1];return l*=l,r1&&n.push(A):n.push(A),n.push(e[t+3])}else{const i=.5,a=e[t+0],r=e[t+1],s=e[t+2],o=e[t+3],l=lerp(a,r,i),c=lerp(r,s,i),d=lerp(s,o,i),h=lerp(l,c,i),u=lerp(c,d,i),g=lerp(h,u,i);getPointsOnBezierCurveWithSplitting([a,l,h,g],0,A,n),getPointsOnBezierCurveWithSplitting([g,u,d,o],0,A,n)}return n}function simplify(e,t){return simplifyPoints(e,0,e.length,t)}function simplifyPoints(e,t,A,i,n){const a=n||[],r=e[t],s=e[A-1];let o=0,l=1;for(let i=t+1;io&&(o=t,l=i)}return Math.sqrt(o)>i?(simplifyPoints(e,t,l+1,i,a),simplifyPoints(e,l,A,i,a)):(a.length||a.push(r),a.push(s)),a}function pointsOnBezierCurves(e,t=.15,A){const i=[],n=(e.length-1)/3;for(let A=0;A0?simplifyPoints(i,0,i.length,A):i}const COMMAND=0,NUMBER=1,EOD=2,PARAMS={A:7,a:7,C:6,c:6,H:1,h:1,L:2,l:2,M:2,m:2,Q:4,q:4,S:4,s:4,T:2,t:2,V:1,v:1,Z:0,z:0};function tokenize(e){const t=new Array;for(;""!==e;)if(e.match(/^([ \t\r\n,]+)/))e=e.substr(RegExp.$1.length);else if(e.match(/^([aAcChHlLmMqQsStTvVzZ])/))t[t.length]={type:0,text:RegExp.$1},e=e.substr(RegExp.$1.length);else{if(!e.match(/^(([-+]?[0-9]+(\.[0-9]*)?|[-+]?\.[0-9]+)([eE][-+]?[0-9]+)?)/))return[];t[t.length]={type:1,text:`${parseFloat(RegExp.$1)}`},e=e.substr(RegExp.$1.length)}return t[t.length]={type:2,text:""},t}function isType(e,t){return e.type===t}function parsePath(e){const t=[],A=tokenize(e);let i="BOD",n=0,a=A[n];for(;!isType(a,2);){let r=0;const s=[];if("BOD"===i){if("M"!==a.text&&"m"!==a.text)return parsePath("M0,0"+e);n++,r=PARAMS[a.text],i=a.text}else isType(a,1)?r=PARAMS[i]:(n++,r=PARAMS[a.text],i=a.text);if(!(n+ri%2?e+A:e+t));a.push({key:"C",data:e}),t=e[4],A=e[5];break}case"Q":a.push({key:"Q",data:[...s]}),t=s[2],A=s[3];break;case"q":{const e=s.map(((e,i)=>i%2?e+A:e+t));a.push({key:"Q",data:e}),t=e[2],A=e[3];break}case"A":a.push({key:"A",data:[...s]}),t=s[5],A=s[6];break;case"a":t+=s[5],A+=s[6],a.push({key:"A",data:[s[0],s[1],s[2],s[3],s[4],t,A]});break;case"H":a.push({key:"H",data:[...s]}),t=s[0];break;case"h":t+=s[0],a.push({key:"H",data:[t]});break;case"V":a.push({key:"V",data:[...s]}),A=s[0];break;case"v":A+=s[0],a.push({key:"V",data:[A]});break;case"S":a.push({key:"S",data:[...s]}),t=s[2],A=s[3];break;case"s":{const e=s.map(((e,i)=>i%2?e+A:e+t));a.push({key:"S",data:e}),t=e[2],A=e[3];break}case"T":a.push({key:"T",data:[...s]}),t=s[0],A=s[1];break;case"t":t+=s[0],A+=s[1],a.push({key:"T",data:[t,A]});break;case"Z":case"z":a.push({key:"Z",data:[]}),t=i,A=n}return a}function normalize(e){const t=[];let A="",i=0,n=0,a=0,r=0,s=0,o=0;for(const{key:l,data:c}of e){switch(l){case"M":t.push({key:"M",data:[...c]}),[i,n]=c,[a,r]=c;break;case"C":t.push({key:"C",data:[...c]}),i=c[4],n=c[5],s=c[2],o=c[3];break;case"L":t.push({key:"L",data:[...c]}),[i,n]=c;break;case"H":i=c[0],t.push({key:"L",data:[i,n]});break;case"V":n=c[0],t.push({key:"L",data:[i,n]});break;case"S":{let e=0,a=0;"C"===A||"S"===A?(e=i+(i-s),a=n+(n-o)):(e=i,a=n),t.push({key:"C",data:[e,a,...c]}),s=c[0],o=c[1],i=c[2],n=c[3];break}case"T":{const[e,a]=c;let r=0,l=0;"Q"===A||"T"===A?(r=i+(i-s),l=n+(n-o)):(r=i,l=n);const d=i+2*(r-i)/3,h=n+2*(l-n)/3,u=e+2*(r-e)/3,g=a+2*(l-a)/3;t.push({key:"C",data:[d,h,u,g,e,a]}),s=r,o=l,i=e,n=a;break}case"Q":{const[e,A,a,r]=c,l=i+2*(e-i)/3,d=n+2*(A-n)/3,h=a+2*(e-a)/3,u=r+2*(A-r)/3;t.push({key:"C",data:[l,d,h,u,a,r]}),s=e,o=A,i=a,n=r;break}case"A":{const e=Math.abs(c[0]),A=Math.abs(c[1]),a=c[2],r=c[3],s=c[4],o=c[5],l=c[6];0===e||0===A?(t.push({key:"C",data:[i,n,o,l,o,l]}),i=o,n=l):i===o&&n===l||(arcToCubicCurves(i,n,o,l,e,A,a,r,s).forEach((function(e){t.push({key:"C",data:e})})),i=o,n=l);break}case"Z":t.push({key:"Z",data:[]}),i=a,n=r}A=l}return t}function degToRad(e){return Math.PI*e/180}function rotate(e,t,A){return[e*Math.cos(A)-t*Math.sin(A),e*Math.sin(A)+t*Math.cos(A)]}function arcToCubicCurves(e,t,A,i,n,a,r,s,o,l){const c=degToRad(r);let d=[],h=0,u=0,g=0,p=0;if(l)[h,u,g,p]=l;else{[e,t]=rotate(e,t,-c),[A,i]=rotate(A,i,-c);const r=(e-A)/2,l=(t-i)/2;let d=r*r/(n*n)+l*l/(a*a);d>1&&(d=Math.sqrt(d),n*=d,a*=d);const m=n*n,w=a*a,f=m*w-m*l*l-w*r*r,E=m*l*l+w*r*r,B=(s===o?-1:1)*Math.sqrt(Math.abs(f/E));g=B*n*l/a+(e+A)/2,p=B*-a*r/n+(t+i)/2,h=Math.asin(parseFloat(((t-p)/a).toFixed(9))),u=Math.asin(parseFloat(((i-p)/a).toFixed(9))),eu&&(h-=2*Math.PI),!o&&u>h&&(u-=2*Math.PI)}let m=u-h;if(Math.abs(m)>120*Math.PI/180){const e=u,t=A,s=i;u=o&&u>h?h+120*Math.PI/180*1:h+120*Math.PI/180*-1,d=arcToCubicCurves(A=g+n*Math.cos(u),i=p+a*Math.sin(u),t,s,n,a,r,0,o,[u,e,g,p])}m=u-h;const w=Math.cos(h),f=Math.sin(h),E=Math.cos(u),B=Math.sin(u),b=Math.tan(m/4),v=4/3*n*b,C=4/3*a*b,y=[e,t],F=[e+v*f,t-C*w],x=[A+v*B,i-C*E],S=[A,i];if(F[0]=2*y[0]-F[0],F[1]=2*y[1]-F[1],l)return[F,x,S].concat(d);{d=[F,x,S].concat(d);const e=[];for(let t=0;t{s.length>=4&&a.push(...pointsOnBezierCurves(s,t)),s=[]},l=()=>{o(),a.length&&(n.push(a),a=[])};for(const{key:e,data:t}of i)switch(e){case"M":l(),r=[t[0],t[1]],a.push(r);break;case"L":o(),a.push([t[0],t[1]]);break;case"C":if(!s.length){const e=a.length?a[a.length-1]:r;s.push([e[0],e[1]])}s.push([t[0],t[1]]),s.push([t[2],t[3]]),s.push([t[4],t[5]]);break;case"Z":o(),a.push([r[0],r[1]])}if(l(),!A)return n;const c=[];for(const e of n){const t=simplify(e,A);t.length&&c.push(t)}return c}const SUPPORTED_TAGS=["svg","path","g","use","circle","ellipse","rect","polyline","polygon"],nodeValidator=e=>SUPPORTED_TAGS.includes(e.tagName)?NodeFilter.FILTER_ACCEPT:NodeFilter.FILTER_REJECT;function createTreeWalker(e){return document.createTreeWalker(e,NodeFilter.SHOW_ALL,{acceptNode:nodeValidator})}const presAttrs=(e,t)=>Object.assign(Object.assign(Object.assign({},getGroupAttrs(t)),presAttrsToElementValues(e)),filterAttrsToElementValues(e)),skippedUseAttrs=["id"],allwaysPassedUseAttrs=["x","y","width","height","href","xlink:href"],getDefElWithCorrectAttrs=(e,t)=>[...t.attributes].reduce(((A,i)=>(skippedUseAttrs.includes(i.value)||e.hasAttribute(i.name)&&!allwaysPassedUseAttrs.includes(i.name)||A.setAttribute(i.name,t.getAttribute(i.name)||""),A)),e.cloneNode()),walkers={svg:e=>{walk(e,e.tw.nextNode())},g:e=>{const t=Object.assign(Object.assign({},e),{tw:createTreeWalker(e.tw.currentNode),groups:[...e.groups,new Group(e.tw.currentNode)]});walk(t,t.tw.nextNode()),walk(e,e.tw.nextSibling())},use:e=>{const{root:t,tw:A,scene:i}=e,n=A.currentNode,a=n.getAttribute("href")||n.getAttribute("xlink:href");if(!a)throw new Error("unable to get id of use element");const r=t.querySelector(a);if(!r)throw new Error(`unable to find def element with id: ${a}`);const s=new ExcalidrawScene,o=getDefElWithCorrectAttrs(r,n);walk(Object.assign(Object.assign({},e),{scene:s,tw:createTreeWalker(o)}),o);const l=s.elements.pop();l&&i.elements.push(l),walk(e,e.tw.nextNode())},circle:e=>{const{tw:t,scene:A,groups:i}=e,n=t.currentNode,a=getNum(n,"r",0),r=2*a,s=getNum(n,"x",0)+getNum(n,"cx",0)-a,o=getNum(n,"y",0)+getNum(n,"cy",0)-a,l=getTransformMatrix(n,i),c=fromValues$1(r,0,0,0,0,r,0,0,0,0,1,0,s,o,0,1),d=multiply(create$1(),l,c),h=Object.assign(Object.assign(Object.assign({},createExEllipse()),presAttrs(n,i)),{x:d[12],y:d[13],width:d[0],height:d[5],groupIds:i.map((e=>e.id))});A.elements.push(h),walk(e,t.nextNode())},ellipse:e=>{const{tw:t,scene:A,groups:i}=e,n=t.currentNode,a=getNum(n,"rx",0),r=getNum(n,"ry",0),s=getNum(n,"cx",0),o=getNum(n,"cy",0),l=getNum(n,"x",0)+s-a,c=getNum(n,"y",0)+o-r,d=2*a,h=2*r,u=getTransformMatrix(n,i),g=fromValues$1(d,0,0,0,0,h,0,0,0,0,1,0,l,c,0,1),p=multiply(create$1(),u,g),m=Object.assign(Object.assign(Object.assign({},createExEllipse()),presAttrs(n,i)),{x:p[12],y:p[13],width:p[0],height:p[5],groupIds:i.map((e=>e.id))});A.elements.push(m),walk(e,t.nextNode())},line:e=>{walk(e,e.tw.nextNode())},polygon:e=>{const{tw:t,scene:A,groups:i}=e,n=t.currentNode,a=transformPoints(pointsAttrToPoints(n),getTransformMatrix(n,i)),r=a[0][0],s=a[0][1],o=a.map((([e,t])=>[e-r,t-s])),[l,c]=dimensionsFromPoints(o),d=Object.assign(Object.assign(Object.assign(Object.assign({},createExLine()),getGroupAttrs(i)),presAttrsToElementValues(n)),{points:o.concat([[0,0]]),x:r,y:s,width:l,height:c});A.elements.push(d),walk(e,e.tw.nextNode())},polyline:e=>{const{tw:t,scene:A,groups:i}=e,n=t.currentNode,a=getTransformMatrix(n,i),r=transformPoints(pointsAttrToPoints(n),a),s=r[0][0],o=r[0][1],l=r.map((([e,t])=>[e-s,t-o])),[c,d]=dimensionsFromPoints(l),h=has(n,"fill"),u=get(n,"fill"),g=!h||h&&"none"!==u,p=Object.assign(Object.assign(Object.assign(Object.assign({},createExLine()),getGroupAttrs(i)),presAttrsToElementValues(n)),{points:l.concat(g?[[0,0]]:[]),x:s,y:o,width:c,height:d});A.elements.push(p),walk(e,e.tw.nextNode())},rect:e=>{const{tw:t,scene:A,groups:i}=e,n=t.currentNode,a=getNum(n,"x",0),r=getNum(n,"y",0),s=getNum(n,"width",0),o=getNum(n,"height",0),l=getTransformMatrix(n,i),c=fromValues$1(s,0,0,0,0,o,0,0,0,0,1,0,a,r,0,1),d=multiply(create$1(),l,c),h=n.hasAttribute("rx")||n.hasAttribute("ry"),u=Object.assign(Object.assign(Object.assign({},createExRect()),presAttrs(n,i)),{x:d[12],y:d[13],width:d[0],height:d[5],roundness:h?{type:ROUNDNESS.LEGACY}:null});A.elements.push(u),walk(e,e.tw.nextNode())},path:e=>{const{tw:t,scene:A,groups:i}=e,n=t.currentNode,a=getTransformMatrix(n,i),r=pointsOnPath(get(n,"d")),s=get(n,"fill","black"),o=get(n,"fill-rule","nonzero");let l=[],c=randomId();switch(o){case"nonzero":let e="clockwise";l=r.map(((t,A)=>{const r=transformPoints(t,clone(a)),o=r[0][0],l=r[0][1],[d,h]=dimensionsFromPoints(r),u=r.map((([e,t])=>[e-o,t-l])),g=getWindingOrder(u);0===A&&(e=g,c=randomId());let p=s;return e!==g&&(p="#FFFFFF"),Object.assign(Object.assign(Object.assign(Object.assign({},createExDraw()),{strokeWidth:0,strokeColor:"#00000000"}),presAttrs(n,i)),{points:u,backgroundColor:p,width:d,height:h,x:o+getNum(n,"x",0),y:l+getNum(n,"y",0),groupIds:[c]})}));break;case"evenodd":l=r.map(((e,t)=>{const A=transformPoints(e,clone(a)),r=A[0][0],s=A[0][1],[o,l]=dimensionsFromPoints(A),d=A.map((([e,t])=>[e-r,t-s]));return 0===t&&(c=randomId()),Object.assign(Object.assign(Object.assign({},createExDraw()),presAttrs(n,i)),{points:d,width:o,height:l,x:r+getNum(n,"x",0),y:s+getNum(n,"y",0)})}))}A.elements=A.elements.concat(l),walk(e,t.nextNode())}};function walk(e,t){if(!t)return;const A=t.nodeName;walkers[A]&&walkers[A](e)}const svgToExcalidraw=e=>{const t=(new DOMParser).parseFromString(e,"image/svg+xml"),A=t.querySelectorAll("parsererror"),i=A.length>0;let n=null;if(i)console.error("There were errors while parsing the given SVG: ",[...A].map((e=>e.innerHTML)));else{const e=createTreeWalker(t),A=new ExcalidrawScene;walk({tw:e,scene:A,groups:[],root:t},e.nextNode()),n=A.elements}return{hasErrors:i,errors:i?A:null,content:n}};B([r$d,z,e$a,l$3,b$1,v,h$1,i$5,i$4,h,u,c$1,s]);const GAP=4;class ExcalidrawAutomate{get obsidian(){return obsidian_module__namespace}get DEVICE(){return DEVICE}async getAttachmentFilepath(e){var t;if(!this.targetView||!(null===(t=this.targetView)||void 0===t?void 0:t.file))return errorMessage("targetView not set","getAttachmentFolderAndFilePath()"),null;const A=await getAttachmentsFolderAndFilePath(app,this.targetView.file.path,e);return getNewUniqueFilepath(app.vault,e,A.folder)}async newFilePrompt(e,t,A,i){var n;if(!this.targetView||!(null===(n=this.targetView)||void 0===n?void 0:n.file))return errorMessage("targetView not set","newFileActions()"),null;const a=emulateKeysForLinkClick(A),r=new NewFileActions(this.plugin,e,a,this.targetView,t,i);return r.open(),await r.waitForClose}getLeaf(e,t){const A=emulateKeysForLinkClick(null!=t?t:"new-tab");return getLeaf(this.plugin,e,A)}constructor(e,t){this.mostRecentMarkdownSVG=null,this.targetView=null,this.onViewUnloadHook=null,this.onViewModeChangeHook=null,this.onLinkHoverHook=null,this.onLinkClickHook=null,this.onDropHook=null,this.onPasteHook=null,this.onCanvasColorChangeHook=null,this.activeScript=null,this.plugin=e,this.reset(),this.targetView=t}getViewLastPointerPosition(){var e;return this.targetView&&(null===(e=this.targetView)||void 0===e?void 0:e._loaded)?this.targetView.currentPosition:(errorMessage("targetView not set","getExcalidrawAPI()"),null)}getAPI(e){return new ExcalidrawAutomate(this.plugin,e)}setFillStyle(e){switch(e){case 0:return this.style.fillStyle="hachure","hachure";case 1:return this.style.fillStyle="cross-hatch","cross-hatch";default:return this.style.fillStyle="solid","solid"}}setStrokeStyle(e){switch(e){case 0:return this.style.strokeStyle="solid","solid";case 1:return this.style.strokeStyle="dashed","dashed";default:return this.style.strokeStyle="dotted","dotted"}}setStrokeSharpness(e){return 0===e?(this.style.roundness={type:ROUNDNESS.LEGACY},"round"):(this.style.roundness=null,"sharp")}setFontFamily(e){switch(e){case 1:return this.style.fontFamily=4,getFontFamily(4);case 2:return this.style.fontFamily=2,getFontFamily(2);case 3:return this.style.fontFamily=3,getFontFamily(3);default:return this.style.fontFamily=1,getFontFamily(1)}}setTheme(e){return 0===e?(this.canvas.theme="light","light"):(this.canvas.theme="dark","dark")}addToGroup(e){const t=nanoid();return e.forEach((e=>{var A,i;null===(i=null===(A=this.elementsDict[e])||void 0===A?void 0:A.groupIds)||void 0===i||i.push(t)})),t}async toClipboard(e){const t=e?await getTemplate(this.plugin,e,!1,new EmbeddedFilesLoader(this.plugin),0):null;let A=t?t.elements:[];A=A.concat(this.getElements()),navigator.clipboard.writeText(JSON.stringify({type:"excalidraw/clipboard",elements:A}))}async getSceneFromFile(e){if(!e)return errorMessage("file not found","getScene()"),null;if(!this.isExcalidrawFile(e))return errorMessage("file is not an Excalidraw file","getScene()"),null;const t=await getTemplate(this.plugin,e.path,!1,new EmbeddedFilesLoader(this.plugin),0);return{elements:t.elements,appState:t.appState}}getElements(){const e=[],t=Object.keys(this.elementsDict);for(let A=0;A{let t=e.plaintext?e.plaintext+"\n\n":"";const A=this.getElements().filter((e=>"text"===e.type));return t+="# Text Elements\n",A.forEach((e=>{var A,i;t+=`${null!==(A=e.rawText)&&void 0!==A?A:null!==(i=e.originalText)&&void 0!==i?i:e.text} ^${e.id}\n\n`})),this.getElements().filter((e=>"text"!==e.type&&e.link)).forEach((e=>{t+=`${e.link} ^${e.id}\n\n`})),t+=Object.keys(this.imagesDict).length>0?"\n# Embedded files\n":"",Object.keys(this.imagesDict).forEach((e=>{const A=this.imagesDict[e];A.latex?t+=`${e}: $$${A.latex}$$\n`:t+=`${e}: [[${A.file}]]\n`})),t})()+getMarkdownDrawingSection(JSON.stringify(G,null,"\t"),this.plugin.settings.compress))}async createSVG(e,t=!1,A,i,n,a){return n||(n=this.plugin.settings.previewMatchObsidianTheme?isObsidianThemeDark()?"dark":"light":this.plugin.settings.exportWithTheme?void 0:"light"),n&&!A&&(A={withBackground:this.plugin.settings.exportWithBackground,withTheme:!0}),i||(i=new EmbeddedFilesLoader(this.plugin,n?"dark"===n:void 0)),await createSVG(e,t,A,i,n,this.canvas.theme,this.canvas.viewBackgroundColor,this.getElements(),this.plugin,0,a,this.imagesDict)}async createPNG(e,t=1,A,i,n,a){return n||(n=this.plugin.settings.previewMatchObsidianTheme?isObsidianThemeDark()?"dark":"light":this.plugin.settings.exportWithTheme?void 0:"light"),n&&!A&&(A={withBackground:this.plugin.settings.exportWithBackground,withTheme:!0}),i||(i=new EmbeddedFilesLoader(this.plugin,n?"dark"===n:void 0)),await createPNG(e,t,A,i,n,this.canvas.theme,this.canvas.viewBackgroundColor,this.getElements(),this.plugin,0,a,this.imagesDict)}wrapText(e,t){return wrapTextAtCharLength(e,t,this.plugin.settings.forceWrap)}boxedElement(e,t,A,i,n,a,r=null){return{id:e,type:t,x:A,y:i,width:n,height:a,angle:this.style.angle,strokeColor:this.style.strokeColor,backgroundColor:this.style.backgroundColor,fillStyle:this.style.fillStyle,strokeWidth:this.style.strokeWidth,strokeStyle:this.style.strokeStyle,roughness:this.style.roughness,opacity:this.style.opacity,roundness:this.style.strokeSharpness?"round"===this.style.strokeSharpness?{type:ROUNDNESS.ADAPTIVE_RADIUS}:null:this.style.roundness,seed:Math.floor(1e5*Math.random()),version:1,versionNonce:Math.floor(1e9*Math.random()),updated:Date.now(),isDeleted:!1,groupIds:[],boundElements:[],link:r,locked:!1}}addIFrame(e,t,A,i,n,a){return this.addEmbeddable(e,t,A,i,n,a)}addEmbeddable(e,t,A,i,n,a){var r;if(!this.targetView||!(null===(r=this.targetView)||void 0===r?void 0:r._loaded))return errorMessage("targetView not set","addEmbeddable()"),null;if(!n&&!a)return errorMessage("Either the url or the file must be set. If both are provided the URL takes precedence","addEmbeddable()"),null;const s=nanoid();return this.elementsDict[s]=this.boxedElement(s,"embeddable",e,t,A,i,n||(a?`[[${app.metadataCache.fileToLinktext(a,this.targetView.file.path,"md"===a.extension)}]]`:"")),s}addRect(e,t,A,i){const n=nanoid();return this.elementsDict[n]=this.boxedElement(n,"rectangle",e,t,A,i),n}addDiamond(e,t,A,i){const n=nanoid();return this.elementsDict[n]=this.boxedElement(n,"diamond",e,t,A,i),n}addEllipse(e,t,A,i){const n=nanoid();return this.elementsDict[n]=this.boxedElement(n,"ellipse",e,t,A,i),n}addBlob(e,t,A,i){const n=.5*i,a=.5*A,r=a/9,s=.8*n,o=[],l=(A,i)=>{const l=A+Math.random()*r-r/2;o.push([l+Math.random()*r-r/2+A%2*r/6+e,i*Math.sqrt(n*n*(1-l*l/(a*a)))+Math.random()*s-s/2+A%2*s/6+t])};let c;for(c=r/2-a;c<=a-r/2;c+=a/6)l(c,1);for(c=a-r/2;c>=r/2-a;c-=a/6)l(c,-1);o.push(o[0]);const d=this.addLine((e=>{const t=getLineBox(e),n=A/t.w,a=i/t.h;let r;for(r=0;r500){const e=500/Math.max(s.size.width,s.size.height);s.size.width=e*s.size.width,s.size.height=e*s.size.height}return this.elementsDict[a]=this.boxedElement(a,"image",e,t,s.size.width,s.size.height),this.elementsDict[a].fileId=o,this.elementsDict[a].scale=[1,1],a}async addLaTex(e,t,A){const i=nanoid(),n=await tex2dataURL(A,this.plugin);return n?(this.imagesDict[n.fileId]={mimeType:n.mimeType,id:n.fileId,dataURL:n.dataURL,created:n.created,file:null,hasSVGwithBitmap:!1,latex:A},this.elementsDict[i]=this.boxedElement(i,"image",e,t,n.size.width,n.size.height),this.elementsDict[i].fileId=n.fileId,this.elementsDict[i].scale=[1,1],i):null}connectObjects(e,t,A,i,n){if(!this.elementsDict[e]||!this.elementsDict[A])return;if(["line","arrow","freedraw"].includes(this.elementsDict[e].type)||["line","arrow","freedraw"].includes(this.elementsDict[A].type))return;const a=(null==n?void 0:n.padding)?n.padding:10,r=(null==n?void 0:n.numberOfPoints)?n.numberOfPoints:0,s=(e,t)=>{switch(e){case"bottom":return[(t.x+(t.x+t.width))/2,t.y+t.height+a];case"left":return[t.x-a,(t.y+(t.y+t.height))/2];case"right":return[t.x+t.width+a,(t.y+(t.y+t.height))/2];default:return[(t.x+(t.x+t.width))/2,t.y-a]}};let o,l,c,d;const h=this.elementsDict[e],u=this.elementsDict[A];if(!t||!i){const e=h.x+h.width/2,A=u.x+u.width/2,n=h.y+h.height/2,a=u.y+u.height/2;if(!t){const t=intersectElementWithLine(h,[A,a],[e,n],4);0===t.length?[o,l]=[e,n]:[o,l]=t[0]}if(!i){const t=intersectElementWithLine(u,[e,n],[A,a],4);0===t.length?[c,d]=[A,a]:[c,d]=t[0]}}t&&([o,l]=s(t,this.elementsDict[e])),i&&([c,d]=s(i,this.elementsDict[A]));const g=r+2,p=[];for(let e=0;eMath.PI/2&&(i-=Math.PI),this.style.angle=i;const a=this.addText(A.x+A.points[1][0]/2-n.width/2,A.y+A.points[1][1]/2-n.height,t);return this.style.angle=0,a}clear(){this.elementsDict={},this.imagesDict={}}reset(){this.clear(),this.activeScript=null,this.style={strokeColor:"#000000",backgroundColor:"transparent",angle:0,fillStyle:"hachure",strokeWidth:1,strokeStyle:"solid",roughness:1,opacity:100,roundness:null,fontFamily:1,fontSize:20,textAlign:"left",verticalAlign:"top",startArrowHead:null,endArrowHead:"arrow"},this.canvas={theme:"light",viewBackgroundColor:"#FFFFFF",gridSize:0}}isExcalidrawFile(e){return this.plugin.isExcalidrawFile(e)}setView(e){if(!e){const e=app.workspace.getActiveViewOfType(ExcalidrawView);if(e instanceof ExcalidrawView)this.targetView=e;else{const e=app.workspace.getLeavesOfType("excalidraw");if(!e||0==e.length)return;this.targetView=e[0].view}}if("active"==e){const e=app.workspace.getActiveViewOfType(ExcalidrawView);if(!(e instanceof ExcalidrawView))return;this.targetView=e}if("first"==e){const e=app.workspace.getLeavesOfType("excalidraw");if(!e||0==e.length)return;this.targetView=e[0].view}return e instanceof ExcalidrawView&&(this.targetView=e),this.targetView}getExcalidrawAPI(){var e;return this.targetView&&(null===(e=this.targetView)||void 0===e?void 0:e._loaded)?this.targetView.excalidrawAPI:(errorMessage("targetView not set","getExcalidrawAPI()"),null)}getViewElements(){var e;if(!this.targetView||!(null===(e=this.targetView)||void 0===e?void 0:e._loaded))return errorMessage("targetView not set","getViewElements()"),[];const t=this.targetView.excalidrawAPI;return t?t.getSceneElements():[]}deleteViewElements(e){var t,A,i;if(!this.targetView||!(null===(t=this.targetView)||void 0===t?void 0:t._loaded))return errorMessage("targetView not set","deleteViewElements()"),!1;const n=null===(i=null===(A=this.targetView)||void 0===A?void 0:A.excalidrawRef)||void 0===i?void 0:i.current;if(!n)return!1;const a=n.getSceneElements(),r=n.getAppState();return this.targetView.updateScene({elements:a.filter((t=>!e.includes(t))),appState:r,commitToHistory:!0}),!0}getViewSelectedElement(){const e=this.getViewSelectedElements();return e?e[0]:null}getViewSelectedElements(){var e;return this.targetView&&(null===(e=this.targetView)||void 0===e?void 0:e._loaded)?this.targetView.getViewSelectedElements():(errorMessage("targetView not set","getViewSelectedElements()"),[])}getViewFileForImageElement(e){var t,A,i,n;return this.targetView&&(null===(t=this.targetView)||void 0===t?void 0:t._loaded)?e&&"image"===e.type?null===(n=null===(i=null===(A=this.targetView)||void 0===A?void 0:A.excalidrawData)||void 0===i?void 0:i.getFile(e.fileId))||void 0===n?void 0:n.file:(errorMessage("Must provide an image element as input","getViewFileForImageElement()"),null):(errorMessage("targetView not set","getViewFileForImageElement()"),null)}copyViewElementsToEAforEditing(e){e.forEach((e=>{this.elementsDict[e.id]=cloneElement(e)}))}viewToggleFullScreen(e=!1){var t,A,i;if(!this.targetView||!(null===(t=this.targetView)||void 0===t?void 0:t._loaded))return void errorMessage("targetView not set","viewToggleFullScreen()");const n=this.targetView,a=n.isFullscreen();e&&(n.updateScene({appState:{viewModeEnabled:!a},commitToHistory:!1}),null===(i=null===(A=this.targetView.toolsPanelRef)||void 0===A?void 0:A.current)||void 0===i||i.setExcalidrawViewMode(!a)),a?n.exitFullscreen():n.gotoFullscreen()}setViewModeEnabled(e){var t,A,i;if(!this.targetView||!(null===(t=this.targetView)||void 0===t?void 0:t._loaded))return void errorMessage("targetView not set","viewToggleFullScreen()");const n=this.targetView;n.updateScene({appState:{viewModeEnabled:e}}),null===(i=null===(A=n.toolsPanelRef)||void 0===A?void 0:A.current)||void 0===i||i.setExcalidrawViewMode(e)}viewUpdateScene(e,t=!1){var A;this.targetView&&(null===(A=this.targetView)||void 0===A?void 0:A._loaded)?this.targetView.updateScene(e,t):errorMessage("targetView not set","viewToggleFullScreen()")}connectObjectWithViewSelectedElement(e,t,A,i){const n=this.getViewSelectedElement();if(!n)return!1;const a=n.id;return this.elementsDict[a]=n,this.connectObjects(e,t,a,A,i),delete this.elementsDict[a],!0}viewZoomToElements(e,t){var A;this.targetView&&(null===(A=this.targetView)||void 0===A?void 0:A._loaded)?this.targetView.zoomToElements(e,t):errorMessage("targetView not set","viewToggleFullScreen()")}async addElementsToView(e=!1,t=!0,A=!1,i=!1){var n;if(!this.targetView||!(null===(n=this.targetView)||void 0===n?void 0:n._loaded))return errorMessage("targetView not set","addElementsToView()"),!1;const a=this.getElements();return await this.targetView.addElements(a,e,t,this.imagesDict,A,i)}registerThisAsViewEA(){var e;return this.targetView&&(null===(e=this.targetView)||void 0===e?void 0:e._loaded)?(this.targetView.setHookServer(this),!0):(errorMessage("targetView not set","addElementsToView()"),!1)}deregisterThisAsViewEA(){var e;return this.targetView&&(null===(e=this.targetView)||void 0===e?void 0:e._loaded)?(this.targetView.setHookServer(this),!0):(errorMessage("targetView not set","addElementsToView()"),!1)}getEmbeddedFilesLoader(e){return new EmbeddedFilesLoader(this.plugin,e)}getExportSettings(e,t){return{withBackground:e,withTheme:t}}getBoundingBox(e){const t=getCommonBoundingBox(e);return{topX:t.minX,topY:t.minY,width:t.maxX-t.minX,height:t.maxY-t.minY}}getMaximumGroups(e){return getMaximumGroups(e)}getLargestElement(e){if(!e||0===e.length)return null;let t=e[0];const A=e=>e.height*e.width;let i=A(e[0]);for(let n=1;ni&&(i=a,t=e[n])}return t}intersectElementWithLine(e,t,A,i){return intersectElementWithLine(e,t,A,i)}getCommonGroupForElements(e){const t=e.map((e=>e.groupIds)).reduce(((e,t)=>t.filter((t=>e.includes(t)))));return t.length>0?t[0]:null}getElementsInTheSameGroupWithElement(e,t){if(!e||!t)return[];const A="text"===e.type&&e.containerId?t.filter((t=>t.id===e.containerId)):[];return 0===e.groupIds.length?1===A.length?[e,A[0]]:[e]:1===A.length?t.filter((t=>t.groupIds.some((t=>e.groupIds.includes(t)))||t===A[0])):t.filter((t=>t.groupIds.some((t=>e.groupIds.includes(t)))))}getElementsInFrame(e,t){return e&&t&&"frame"===e.type?t.filter((t=>t.frameId===e.id)):[]}getScriptSettings(){var e;return this.activeScript?null!==(e=this.plugin.settings.scriptEngineSettings[this.activeScript])&&void 0!==e?e:{}:null}async setScriptSettings(e){if(!this.activeScript)return null;this.plugin.settings.scriptEngineSettings[this.activeScript]=e,await this.plugin.saveSettings()}openFileInNewOrAdjacentLeaf(e){if(!(e&&e instanceof obsidian_module.TFile))return null;if(!this.targetView)return null;const t=getNewOrAdjacentLeaf(this.plugin,this.targetView.leaf);return t.openFile(e,{active:!0}),t}measureText(e){var t,A;const i=_measureText(e,this.style.fontSize,this.style.fontFamily,getDefaultLineHeight(this.style.fontFamily));return{width:null!==(t=i.w)&&void 0!==t?t:0,height:null!==(A=i.h)&&void 0!==A?A:0}}async getOriginalImageSize(e){var t;if(!this.targetView||!(null===(t=this.targetView)||void 0===t?void 0:t._loaded))return errorMessage("targetView not set","getOriginalImageSize()"),null;if(!e||"image"!==e.type)return errorMessage("Please provide a single image element as input","getOriginalImageSize()"),null;const A=this.targetView.excalidrawData.getFile(e.fileId);if(!A)return errorMessage("Please provide a single image element as input","getOriginalImageSize()"),null;const i="dark"===this.getExcalidrawAPI().getAppState().theme,n=A.getImage(i);return await getImageSize(n)}verifyMinimumPluginVersion(e){return verifyMinimumPluginVersion(e)}isExcalidrawView(e){return e instanceof ExcalidrawView}selectElementsInView(e){var t;if(!this.targetView||!(null===(t=this.targetView)||void 0===t?void 0:t._loaded))return void errorMessage("targetView not set","selectElementsInView()");if(!e||0===e.length)return;const A=this.getExcalidrawAPI();if("string"==typeof e[0]){const t=this.getViewElements().filter((t=>e.includes(t.id)));A.selectElements(t)}else A.selectElements(e)}generateElementId(){return nanoid()}cloneElement(e){const t=JSON.parse(JSON.stringify(e));return t.id=nanoid(),t}moveViewElementToZIndex(e,t){var A;if(!this.targetView||!(null===(A=this.targetView)||void 0===A?void 0:A._loaded))return void errorMessage("targetView not set","moveViewElementToZIndex()");const i=this.getExcalidrawAPI(),n=this.getViewElements(),a=n.filter((t=>t.id===e));if(0===a.length)return void errorMessage(`Element (id: ${e}) not found`,"moveViewElementToZIndex");if(t>=n.length)return void i.bringToFront(a);if(t<0)return void i.sendToBack(a);const r=n.indexOf(a[0]);n.splice(t,0,n.splice(r,1)[0]),this.targetView.updateScene({elements:n,commitToHistory:!0})}hexStringToRgb(e){const t=/^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(e);return[parseInt(t[1],16),parseInt(t[2],16),parseInt(t[3],16)]}rgbToHexString(e){return O$1({r:e[0],g:e[1],b:e[2]}).stringHEX({alpha:!1})}hslToRgb(e){const t=O$1({h:e[0],s:e[1],l:e[2]});return[t.red,t.green,t.blue]}rgbToHsl(e){const t=O$1({r:e[0],g:e[1],b:e[2]});return[t.hue,t.saturation,t.lightness]}colorNameToHex(e){return COLOR_NAMES.has(e.toLowerCase().trim())?COLOR_NAMES.get(e.toLowerCase().trim()):e.trim()}getCM(e){if(e)return"string"==typeof e&&(e=this.colorNameToHex(e)),O$1(e);log("Creates a CM object. Visit https://github.com/lbragile/ColorMaster for documentation.")}importSVG(e){const t=svgToExcalidraw(e);return t.hasErrors?(new obsidian_module.Notice(`There were errors while parsing the given SVG:\n${[...t.errors].map((e=>e.innerHTML))}`),!1):(this.copyViewElementsToEAforEditing(t.content),!0)}}async function initExcalidrawAutomate(e){await initFonts();const t=new ExcalidrawAutomate(e);return window.ExcalidrawAutomate=t,t}function destroyExcalidrawAutomate(){delete window.ExcalidrawAutomate}function normalizeLinePoints(e){const t=[],[A,i]=e[0];for(let n=0;n-1||t.search("excalidraw-plugin: locked\n")>-1;await a.loadData(t,l,o?TextMode.parsed:TextMode.raw);let d=t.search("# Text Elements\n");-1==d&&(d=t.search("# Drawing\n"));let h=a.scene;A&&await i.loadSceneFiles(a,(e=>{if(e&&0!==e.length){for(const t of e)t.hasSVGwithBitmap&&(c=!0),a.scene.files[t.id]={mimeType:t.mimeType,id:t.id,dataURL:t.dataURL,created:t.created};h=scaleLoadedImage(a.scene,e).scene}}),n);let u=h.elements;if(s.hasGroupref){const t=s.hasSectionref?getTextElementsMatchingQuery(h.elements,["# "+s.sectionref],!0):h.elements.filter((e=>e.id===s.blockref));t.length>0&&(u=e.ea.getElementsInTheSameGroupWithElement(t[0],h.elements))}if(s.hasFrameref){const t=h.elements.filter((e=>e.id===s.blockref));1===t.length&&(u=e.ea.getElementsInFrame(t[0],h.elements))}return s.hasTaskbone&&(u=u.filter((t=>{var A;return"freedraw"===t.type||"image"===t.type&&!e.isExcalidrawFile(null===(A=a.getFile(t.fileId))||void 0===A?void 0:A.file)}))),{elements:u,appState:h.appState,frontmatter:t.substring(0,d),files:h.files,hasSVGwithBitmap:c}}return{elements:[],appState:{},frontmatter:null,files:[],hasSVGwithBitmap:c}}async function createPNG(e,t=1,A,i,n,a,r,s=[],o,l,c,d){var h,u,g,p,m,w,f;i||(i=new EmbeddedFilesLoader(o)),c=null!=c?c:o.settings.exportPaddingSVG;const E=e?await getTemplate(o,e,!0,i,l):null;let B=null!==(h=null==E?void 0:E.elements)&&void 0!==h?h:[];B=B.concat(s);const b=null!=d?d:{};return(null==E?void 0:E.files)&&Object.values(E.files).forEach((e=>{b[e.id]=e})),await getPNG({type:"excalidraw",version:2,source:GITHUB_RELEASES+PLUGIN_VERSION,elements:B,appState:{theme:null!==(g=null!=n?n:null===(u=null==E?void 0:E.appState)||void 0===u?void 0:u.theme)&&void 0!==g?g:a,viewBackgroundColor:null!==(m=null===(p=null==E?void 0:E.appState)||void 0===p?void 0:p.viewBackgroundColor)&&void 0!==m?m:r},files:b},{withBackground:null!==(w=null==A?void 0:A.withBackground)&&void 0!==w?w:o.settings.exportWithBackground,withTheme:null!==(f=null==A?void 0:A.withTheme)&&void 0!==f?f:o.settings.exportWithTheme},c,t)}async function createSVG(e,t=!1,A,i,n,a,r,s=[],o,l,c,d){var h,u,g,p,m,w,f;i||(i=new EmbeddedFilesLoader(o));const E=e?await getTemplate(o,e,!0,i,l):null;let B=null!==(h=null==E?void 0:E.elements)&&void 0!==h?h:[];B=B.concat(s),c=null!=c?c:o.settings.exportPaddingSVG;const b=null!=d?d:{};(null==E?void 0:E.files)&&Object.values(E.files).forEach((e=>{b[e.id]=e}));const v=await getSVG({type:"excalidraw",version:2,source:GITHUB_RELEASES+PLUGIN_VERSION,elements:B,appState:{theme:null!==(g=null!=n?n:null===(u=null==E?void 0:E.appState)||void 0===u?void 0:u.theme)&&void 0!==g?g:a,viewBackgroundColor:null!==(m=null===(p=null==E?void 0:E.appState)||void 0===p?void 0:p.viewBackgroundColor)&&void 0!==m?m:r},files:b},{withBackground:null!==(w=null==A?void 0:A.withBackground)&&void 0!==w?w:o.settings.exportWithBackground,withTheme:null!==(f=null==A?void 0:A.withTheme)&&void 0!==f?f:o.settings.exportWithTheme},c),C=getEmbeddedFilenameParts(e);if(!C.hasGroupref&&!C.hasFrameref&&(C.hasBlockref||C.hasSectionref)){let e=C.hasSectionref?getTextElementsMatchingQuery(B,["# "+C.sectionref],!0):B.filter((e=>e.id===C.blockref));if(e.length>0){const t=e[0].containerId;t&&(e=e.concat(B.filter((e=>e.id===t))));const A=o.ea.getBoundingBox(e),i=o.ea.getBoundingBox(B);v.viewBox.baseVal.x=A.topX-i.topX,v.viewBox.baseVal.y=A.topY-i.topY,v.viewBox.baseVal.width=A.width+2*c,v.viewBox.baseVal.height=A.height+2*c}}return(null==E?void 0:E.hasSVGwithBitmap)&&v.setAttribute("hasbitmap","true"),t?embedFontsInSVG(v,o):v}function estimateLineBound(e){let t=1/0,A=1/0,i=-1/0,n=-1/0;for(const[a,r]of e)t=Math.min(t,a),A=Math.min(A,r),i=Math.max(i,a),n=Math.max(n,r);return[t,A,i,n]}function estimateBounds(e){const t=getCommonBoundingBox(e);return[t.minX,t.minY,t.maxX,t.maxY]}function repositionElementsToCursor(e,t,A=!1,i){const[n,a,r,s]=estimateBounds(e);let[o,l]=[0,0];return[o,l]=A?[t.x-(n+r)/2,t.y-(a+s)/2]:[t.x-n,t.y-a],e.forEach((e=>{e.x=e.x+o,e.y=e.y+l})),i.restore({elements:e}).elements}function errorMessage(e,t){switch(e){case"targetView not set":errorlog({where:"ExcalidrawAutomate",source:t,message:"targetView not set, or no longer active. Use setView before calling this function"});break;case"mobile not supported":errorlog({where:"ExcalidrawAutomate",source:t,message:"this function is not avalable on Obsidian Mobile"});break;default:errorlog({where:"ExcalidrawAutomate",source:t,message:null!=e?e:"unknown error"})}}const insertLaTeXToView=e=>{const t=e.plugin.app,A=e.plugin.ea;new Prompt(t,t$d("ENTER_LATEX"),e.plugin.settings.latexBoilerplate,"\\color{red}\\oint_S {E_n dA = \\frac{1}{{\\varepsilon _0 }}} Q_{inside}").openAndGetValue((async t=>{t&&(A.reset(),await A.addLaTex(0,0,t),A.setView(e),A.addElementsToView(!0,!1,!0))}))},search=async e=>{const t=e.plugin.ea;t.reset(),t.setView(e);const A=t.getViewElements().filter((e=>"text"===e.type||"frame"===e.type));if(0===A.length)return;let i=await ScriptEngine.inputPrompt(e,e.plugin,e.plugin.app,"Search for","use quotation marks for exact match","");if(!i)return;const n=i.matchAll(/"(.*?)"/g);let a,r=[];for(;!(a=n.next()).done;)r.push(a.value[1]);i=i.replaceAll(/"(.*?)"/g,""),r=r.concat(i.split(" ").filter((e=>0!==e.length))),t.targetView.selectElementsMatchingQuery(A,r)},getTextElementsMatchingQuery=(e,t,A=!1)=>e&&0!==e.length&&t&&0!==t.length?e.filter((e=>"text"===e.type&&t.some((t=>{if(A){const A=e.rawText.toLowerCase().split("\n")[0].trim().match(/^#*(# .*)/);return!(!A||2!==A.length)&&A[1]===t.toLowerCase()}return e.rawText.toLowerCase().replaceAll("\n"," ").trim().match(t.toLowerCase())})))):[],getFrameElementsMatchingQuery=(e,t,A=!1)=>e&&0!==e.length&&t&&0!==t.length?e.filter((e=>"frame"===e.type&&t.some((t=>{if(A){const A=e.name.toLowerCase().split("\n")[0].trim().match(/^#*(# .*)/);return!(!A||2!==A.length)&&A[1]===t.toLowerCase()}return(e.name?e.name.toLowerCase().replaceAll("\n"," ").trim():"").match(t.toLowerCase())})))):[],cloneElement=e=>{const t=JSON.parse(JSON.stringify(e));return t.version=e.version+1,t.updated=Date.now(),t.versionNonce=Math.floor(1e9*Math.random()),t},verifyMinimumPluginVersion=e=>PLUGIN_VERSION===e||isVersionNewerThanOther(PLUGIN_VERSION,e),URL$1="https://raw.githubusercontent.com/zsviczian/obsidian-excalidraw-plugin/master/ea-scripts/index-new.md";class ScriptInstallPrompt extends obsidian_module.Modal{constructor(e){super(e.app),this.plugin=e}async onOpen(){this.contentEl.classList.add("excalidraw-scriptengine-install"),this.containerEl.classList.add("excalidraw-scriptengine-install");try{const e=await obsidian_module.request({url:URL$1});if(!e)return new obsidian_module.Notice("Error opening the Excalidraw Script Store page. Please double check that you can access the website. I've logged the link in developer console (press CTRL+SHIFT+i)",5e3),log(URL$1),void this.close();await obsidian_module.MarkdownRenderer.renderMarkdown(e,this.contentEl,"",this.plugin),this.contentEl.querySelectorAll("h1[data-heading],h2[data-heading],h3[data-heading]").forEach((e=>{e.setAttribute("id",e.getAttribute("data-heading"))})),this.contentEl.querySelectorAll("a.internal-link").forEach((e=>{e.removeAttribute("target")}))}catch(e){errorlog({where:"ScriptInstallPrompt.onOpen",error:e}),new obsidian_module.Notice("Could not open ScriptEngine repository"),this.close()}}onClose(){this.contentEl.empty()}}function r(e){var t,A,i="";if("string"==typeof e||"number"==typeof e)i+=e;else if("object"==typeof e)if(Array.isArray(e))for(t=0;t{e.view instanceof ExcalidrawView&&e.view.updatePinnedCustomPens()})),this.plugin.saveSettings();const e=this.plugin.settings.customPens[this.pen],t=this.view.excalidrawAPI;setPen(e,t),t.setActiveTool({type:"freedraw"})}}async createForm(){const e=e=>{let t="";if(COLOR_NAMES.has(e))return[COLOR_NAMES.get(e),t];const A=(new Option).style;if(A.color=e,A.color){const e=A.color.match(/^[^\d]*(\d*)[^\d]*(\d*)[^\d]*(\d*)[^\d]*([\d\.]*)?/);return e?(t=e[4]?(Math.round(255*parseFloat(e[4]))<<0).toString(16).padStart(2,"0"):"",[`#${(parseInt(e[1])<<0).toString(16).padStart(2,"0")}${(parseInt(e[2])<<0).toString(16).padStart(2,"0")}${(parseInt(e[3])<<0).toString(16).padStart(2,"0")}`,t]):[null,t]}return[null,t]},t=this.plugin.settings.customPens[this.pen],A=this.contentEl;let i,n,a,r,s;A.createEl("h1",{text:"Pen settings"}),new obsidian_module.Setting(A).setName("Pen type").setDesc("Select type of pen").addDropdown((e=>{e.addOption("default","Excalidraw Default").addOption("highlighter","Highlighter").addOption("finetip","Fine tip pen").addOption("fountain","Fountain pen").addOption("marker","Marker with Outline").addOption("thick-thin","Mindmap Thick-Thin").addOption("thin-thick-thin","Mindmap Thin-Thick-Thin").setValue(t.type).onChange((e=>{this.dirty=!0,t.type=e}))})).addButton((e=>e.setButtonText("Apply").onClick((()=>{this.dirty=!0,t.strokeColor=PENS[t.type].strokeColor,t.backgroundColor=PENS[t.type].backgroundColor,t.fillStyle=PENS[t.type].fillStyle,t.strokeWidth=PENS[t.type].strokeWidth,t.roughness=PENS[t.type].roughness,t.penOptions=Object.assign({},PENS[t.type].penOptions),A.empty(),this.createForm()})))),i=new obsidian_module.Setting(A).setName(fragWithHTML(t.freedrawOnly?"Stroke & fill applies to: Freedraw only":"Stroke & fill applies to: All shapes")).setDesc(fragWithHTML('"All shapes" means that if for example, you select a blue pen with dashed fill and then switch to a different tool (e.g. to a line, a circle, an arrow - i.e. not the freedraw tool), those will all have the same blue line and dashed fill.
"Only applies to the freedraw line" means that if for example you are writing black text, and you select a custom pen (e.g. a yellow highlighter), then after using the highlighter you switch to another tool, the previous settings (e.g. black stroke color) will apply to the new shape.')).addToggle((e=>e.setValue(t.freedrawOnly).onChange((e=>{this.dirty=!0,i.setName(fragWithHTML(e?"Stroke & fill applies to: Freedraw only":"Stroke & fill applies to: All shapes")),t.freedrawOnly=e}))));let o,l,c,d,h,u,g,[p,m]=e(t.strokeColor),w=!1;s=new obsidian_module.Setting(A).setName(fragWithHTML(Boolean(t.strokeColor)?"Stroke color: Preset color":"Stroke color: Current")).setDesc(fragWithHTML("Use current stroke color of the canvas, or set a specific preset color for the pen")).addToggle((A=>A.setValue(!Boolean(t.strokeColor)).onChange((A=>{this.dirty=!0,n.settingEl.style.display=A?"none":"",s.setName(fragWithHTML(A?"Stroke color: Current":"Stroke color: Preset color")),A?delete t.strokeColor:(r.getValue()||([p,m]=e("black"),a.setValue(p),r.setValue("black")),t.strokeColor=r.getValue())})))),n=new obsidian_module.Setting(A).setName("Select stroke color").addButton((A=>A.setButtonText("Use Canvas Current").onClick((()=>{var A,i;const n=this.api.getAppState(),s=null!==(i=null===(A=n.resetCustomPen)||void 0===A?void 0:A.currentItemStrokeColor)&&void 0!==i?i:n.currentItemStrokeColor;[p,m]=e(s),t.strokeColor=s,this.dirty=!0,r.setValue(s),w=!0,a.setValue(p)})))).addText((A=>{r=A,A.setValue(t.strokeColor).onChange((A=>{w=!0,this.dirty=!0,t.strokeColor=A,[p,m]=e(A),p&&a.setValue(p)}))})).addColorPicker((e=>{a=e,e.setValue(null!=p?p:"#000000").onChange((e=>{w?w=!1:(this.dirty=!0,t.strokeColor=e+m,r.setValue(e+m))}))})),n.settingEl.style.display=Boolean(t.strokeColor)?"":"none";let[f,E]=e(t.backgroundColor);o=new obsidian_module.Setting(A).setName(fragWithHTML(Boolean(t.backgroundColor)?"Background color: Preset color":"Background color: Current")).setDesc(fragWithHTML("Toggle to use the current background color of the canvas; or a preset color")).addToggle((A=>A.setValue(!Boolean(t.backgroundColor)).onChange((A=>{this.dirty=!0,o.setName(fragWithHTML(A?"Background color: Current":"Background color: Preset color")),c.settingEl.style.display=A?"none":"",l.settingEl.style.display=A||"transparent"===t.backgroundColor?"none":"",A?delete t.backgroundColor:(h.getValue()||([f,E]=e("black"),d.setValue(f),h.setValue("black")),u.setValue(!1))})))),c=new obsidian_module.Setting(A).setName(fragWithHTML("transparent"===t.backgroundColor?"Background: Transparent":"Color: Preset color")).setDesc("Background has color or is transparent").addToggle((e=>{u=e,e.setValue("transparent"===t.backgroundColor).onChange((e=>{this.dirty=!0,l.settingEl.style.display=e?"none":"",g.settingEl.style.display=e?"none":"",c.setName(fragWithHTML(e?"Background: Transparent":"Color: Preset color")),t.backgroundColor=e?"transparent":d.getValue()}))})),c.settingEl.style.display=Boolean(t.backgroundColor)?"":"none";let B,b,v,C,y,F,x,S,T,I=!1;l=new obsidian_module.Setting(A).setName("Background color").addButton((A=>A.setButtonText("Use Canvas Current").onClick((()=>{var A,i;const n=this.api.getAppState(),a=null!==(i=null===(A=n.resetCustomPen)||void 0===A?void 0:A.currentItemBackgroundColor)&&void 0!==i?i:n.currentItemBackgroundColor;[f,E]=e(a),t.backgroundColor=a,this.dirty=!0,h.setValue(a),I=!0,d.setValue(f)})))).addText((A=>{h=A,A.setValue(t.backgroundColor).onChange((A=>{I=!0,this.dirty=!0,t.backgroundColor=A,[f,E]=e(A),f&&d.setValue(f)}))})).addColorPicker((e=>{d=e,e.setValue(null!=f?f:"#000000").onChange((e=>{I?I=!1:(this.dirty=!0,t.backgroundColor=e+E,h.setValue(e+E))}))})),l.settingEl.style.display=Boolean(t.backgroundColor)&&"transparent"!==t.backgroundColor?"":"none",g=new obsidian_module.Setting(A).setName("Fill Style").addDropdown((e=>e.addOption("","Unset").addOption("dots","Dots (⚠ VERY SLOW performance on large objects!)").addOption("zigzag","Zigzag").addOption("zigzag-line","Zigzag-line").addOption("dashed","Dashed").addOption("hachure","Hachure").addOption("cross-hatch","Cross-hatch").addOption("solid","Solid").setValue(t.fillStyle).onChange((e=>{this.dirty=!0,t.fillStyle=e})))),g.settingEl.style.display=Boolean(t.backgroundColor)&&"transparent"!==t.backgroundColor?"":"none",B=new obsidian_module.Setting(A).setName(fragWithHTML(`Sloppiness: ${null===t.roughness?"Not Set":t.roughness<=.5?"Architect (":t.roughness<=1.5?"Artist (":"Cartoonist ("}${null===t.roughness?"":`${t.roughness})`}`)).setDesc("Line sloppiness of the shape fill pattern").addSlider((e=>e.setLimits(-.5,3,.5).setValue(null===t.roughness?-.5:t.roughness).onChange((e=>{this.dirty=!0,t.roughness=-.5===e?null:e,B.setName(fragWithHTML(`Sloppiness: ${null===t.roughness?"Not Set":t.roughness<=.5?"Architect (":t.roughness<=1.5?"Artist (":"Cartoonist ("}${null===t.roughness?"":`${t.roughness})`}`))})))),b=new obsidian_module.Setting(A).setName(fragWithHTML(`Stroke Width ${0===t.strokeWidth?"Not Set":t.strokeWidth}`)).addSlider((e=>e.setLimits(0,5,.5).setValue(t.strokeWidth).onChange((e=>{this.dirty=!0,t.strokeWidth=e,b.setName(fragWithHTML(`Stroke Width ${0===t.strokeWidth?"Not Set":t.strokeWidth}`))})))),new obsidian_module.Setting(A).setName("Highlighter pen?").addToggle((e=>e.setValue(t.penOptions.highlighter).onChange((e=>{this.dirty=!0,t.penOptions.highlighter=e})))),new obsidian_module.Setting(A).setName("Pressure sensitve pen?").setDesc(fragWithHTML("toggle on: pressure sensitive
toggle off: constant pressure")).addToggle((e=>e.setValue(!t.penOptions.constantPressure).onChange((e=>{this.dirty=!0,t.penOptions.constantPressure=!e,v.settingEl.style.display=t.penOptions.constantPressure?"none":""})))),t.penOptions.hasOutline&&0===t.penOptions.outlineWidth&&(t.penOptions.outlineWidth=.5,this.dirty=!0),!t.penOptions.hasOutline&&t.penOptions.outlineWidth>0&&(t.penOptions.outlineWidth=0,this.dirty=!0),C=new obsidian_module.Setting(A).setName(fragWithHTML(0===t.penOptions.outlineWidth?"No outline":`Outline width ${t.penOptions.outlineWidth}`)).setDesc("If the stroke has an outline, this will mean the stroke color is the outline color, and the background color is the pen stroke's fill color. If the pen does not have an outline then the pen color is the stroke color. The Fill Style setting applies to the fill style of the enclosed shape, not of the line itself. The line can only have solid fill.").addSlider((e=>e.setLimits(0,8,.5).setValue(t.penOptions.outlineWidth).onChange((e=>{this.dirty=!0,t.penOptions.outlineWidth=e,t.penOptions.hasOutline=e>0,C.setName(fragWithHTML(0===t.penOptions.outlineWidth?"No outline":`Outline width ${t.penOptions.outlineWidth}`))})))),A.createEl("h2",{text:"Perfect Freehand settings"}),A.createEl("p").innerHTML='Read the Perfect Freehand documentation following this link.',y=new obsidian_module.Setting(A).setName(fragWithHTML(`Thinnning ${t.penOptions.options.thinning}`)).setDesc(fragWithHTML("The effect of pressure on the stroke's size.
To create a stroke with a steady line, set the thinning option to 0.
To create a stroke that gets thinner with pressure instead of thicker, use a negative number for the thinning option.")).addSlider((e=>e.setLimits(-1,1,.05).setValue(t.penOptions.options.thinning).onChange((e=>{this.dirty,y.setName(fragWithHTML(`Thinnning ${e}`)),t.penOptions.options.thinning=e})))),F=new obsidian_module.Setting(A).setName(fragWithHTML(`Smoothing ${t.penOptions.options.smoothing}`)).setDesc(fragWithHTML("How much to soften the stroke's edges.")).addSlider((e=>e.setLimits(0,1,.05).setValue(t.penOptions.options.smoothing).onChange((e=>{this.dirty,F.setName(fragWithHTML(`Smoothing ${e}`)),t.penOptions.options.smoothing=e})))),x=new obsidian_module.Setting(A).setName(fragWithHTML(`Streamline ${t.penOptions.options.streamline}`)).setDesc(fragWithHTML("\tHow much to streamline the stroke.")).addSlider((e=>e.setLimits(0,1,.05).setValue(t.penOptions.options.streamline).onChange((e=>{this.dirty,x.setName(fragWithHTML(`Streamline ${e}`)),t.penOptions.options.streamline=e})))),new obsidian_module.Setting(A).setName("Easing function").setDesc(fragWithHTML('An easing function for the tapering effect. For more info click here')).addDropdown((e=>e.addOptions(EASINGFUNCTIONS).setValue(t.penOptions.options.easing).onChange((e=>{this.dirty=!0,t.penOptions.options.easing=e})))),v=new obsidian_module.Setting(A).setName("Simulate Pressure").setDesc("Whether to simulate pressure based on velocity.").addDropdown((e=>e.addOption("true","Always").addOption("false","Never").addOption("","Yes for mouse, No for pen").setValue(!0===t.penOptions.options.simulatePressure?"true":!1===t.penOptions.options.simulatePressure?"false":"").onChange((e=>{switch(this.dirty=!0,e){case"true":t.penOptions.options.simulatePressure=!0;break;case"false":t.penOptions.options.simulatePressure=!1;break;default:delete t.penOptions.options.simulatePressure}})))),v.settingEl.style.display=t.penOptions.constantPressure?"none":"",A.createEl("h3",{text:"Start"}),A.createEl("p",{text:"Tapering options for the start of the line."}),new obsidian_module.Setting(A).setName("Cap Start").setDesc("Whether to draw a cap").addToggle((e=>e.setValue(t.penOptions.options.start.cap).onChange((e=>{this.dirty=!0,t.penOptions.options.start.cap=e})))),S=new obsidian_module.Setting(A).setName(fragWithHTML(`Taper: ${!0===t.penOptions.options.start.taper?"true":t.penOptions.options.start.taper}`)).setDesc("The distance to taper. If set to true, the taper will be the total length of the stroke.").addSlider((e=>e.setLimits(0,151,1).setValue("boolean"==typeof t.penOptions.options.start.taper?151:t.penOptions.options.start.taper).onChange((e=>{this.dirty,t.penOptions.options.start.taper=151===e||e,S.setName(fragWithHTML(`Taper: ${!0===t.penOptions.options.start.taper?"true":t.penOptions.options.start.taper}`))})))),new obsidian_module.Setting(A).setName("Easing function").setDesc(fragWithHTML('An easing function for the tapering effect. For more info click here')).addDropdown((e=>e.addOptions(EASINGFUNCTIONS).setValue(t.penOptions.options.start.easing).onChange((e=>{this.dirty=!0,t.penOptions.options.start.easing=e})))),A.createEl("h3",{text:"End"}),A.createEl("p",{text:"Tapering options for the end of the line."}),new obsidian_module.Setting(A).setName("Cap End").setDesc("Whether to draw a cap").addToggle((e=>e.setValue(t.penOptions.options.end.cap).onChange((e=>{this.dirty=!0,t.penOptions.options.end.cap=e})))),T=new obsidian_module.Setting(A).setName(fragWithHTML(`Taper: ${!0===t.penOptions.options.end.taper?"true":t.penOptions.options.end.taper}`)).setDesc("The distance to taper. If set to true, the taper will be the total length of the stroke.").addSlider((e=>e.setLimits(0,151,1).setValue("boolean"==typeof t.penOptions.options.end.taper?151:t.penOptions.options.end.taper).onChange((e=>{this.dirty,t.penOptions.options.end.taper=151===e||e,T.setName(fragWithHTML(`Taper: ${!0===t.penOptions.options.end.taper?"true":t.penOptions.options.end.taper}`))})))),new obsidian_module.Setting(A).setName("Easing function").setDesc(fragWithHTML('An easing function for the tapering effect. For more info click here')).addDropdown((e=>e.addOptions(EASINGFUNCTIONS).setValue(t.penOptions.options.end.easing).onChange((e=>{this.dirty=!0,t.penOptions.options.end.easing=e}))))}}var defaultAttributes={xmlns:"http://www.w3.org/2000/svg",width:24,height:24,viewBox:"0 0 24 24",fill:"none",stroke:"currentColor",strokeWidth:2,strokeLinecap:"round",strokeLinejoin:"round"};const toKebabCase=e=>e.replace(/([a-z0-9])([A-Z])/g,"$1-$2").toLowerCase(),createLucideIcon=(e,t)=>{const A=React.forwardRef((({color:A="currentColor",size:i=24,strokeWidth:n=2,absoluteStrokeWidth:a,children:r,...s},o)=>{return React.createElement("svg",{ref:o,...defaultAttributes,width:i,height:i,stroke:A,strokeWidth:a?24*Number(n)/Number(i):n,className:`lucide lucide-${l=e,l.replace(/([a-z0-9])([A-Z])/g,"$1-$2").toLowerCase()}`,...s},[...t.map((([e,t])=>React.createElement(e,t))),...(Array.isArray(r)?r:[r])||[]]);var l}));return A.displayName=`${e}`,A},Globe=createLucideIcon("Globe",[["circle",{cx:"12",cy:"12",r:"10",key:"1mglay"}],["line",{x1:"2",x2:"22",y1:"12",y2:"12",key:"1dnqot"}],["path",{d:"M12 2a15.3 15.3 0 0 1 4 10 15.3 15.3 0 0 1-4 10 15.3 15.3 0 0 1-4-10 15.3 15.3 0 0 1 4-10z",key:"nb9nel"}]]),RotateCcw=createLucideIcon("RotateCcw",[["path",{d:"M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8",key:"1357e3"}],["path",{d:"M3 3v5h5",key:"1xhq8a"}]]),Scan=createLucideIcon("Scan",[["path",{d:"M3 7V5a2 2 0 0 1 2-2h2",key:"aa7l1z"}],["path",{d:"M17 3h2a2 2 0 0 1 2 2v2",key:"4qcy5o"}],["path",{d:"M21 17v2a2 2 0 0 1-2 2h-2",key:"6vwrx8"}],["path",{d:"M7 21H5a2 2 0 0 1-2-2v-2",key:"ioqczr"}]]),ICONS={ExportImage:React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",width:"24",height:"24",viewBox:"0 0 24 24",fill:"none",stroke:"var(--icon-fill-color)",strokeWidth:"2",strokeLinecap:"round",strokeLinejoin:"round"},React__namespace.createElement("g",{strokeWidth:"1.25"},React__namespace.createElement("path",{stroke:"none",d:"M0 0h24v24H0z",fill:"none"}),React__namespace.createElement("path",{d:"M15 8h.01"}),React__namespace.createElement("path",{d:"M12 20h-5a3 3 0 0 1 -3 -3v-10a3 3 0 0 1 3 -3h10a3 3 0 0 1 3 3v5"}),React__namespace.createElement("path",{d:"M4 15l4 -4c.928 -.893 2.072 -.893 3 0l4 4"}),React__namespace.createElement("path",{d:"M14 14l1 -1c.617 -.593 1.328 -.793 2.009 -.598"}),React__namespace.createElement("path",{d:"M19 16v6"}),React__namespace.createElement("path",{d:"M22 19l-3 3l-3 -3"}))),Reload:React__namespace.createElement(RotateCcw,null),Globe:React__namespace.createElement(Globe,null),ZoomToSelectedElement:React__namespace.createElement(Scan,null),ZoomToSection:React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 24 24",fill:"none",stroke:"var(--icon-fill-color)",strokeWidth:"1",strokeLinecap:"round",strokeLinejoin:"round"},React__namespace.createElement("text",{x:"6",y:"18",fontSize:"22px"},"#")),ZoomToBlock:React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 24 24",fill:"none",stroke:"var(--icon-fill-color)",strokeWidth:"1",strokeLinecap:"round",strokeLinejoin:"round"},React__namespace.createElement("text",{x:"1",y:"18",fontSize:"22px"},"#^")),Discord:React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",fill:"var(--icon-fill-color)",stroke:"none",strokeWidth:"2",strokeLinecap:"round",strokeLinejoin:"round",viewBox:"0 0 640 512"},React__namespace.createElement("path",{d:"M524.531,69.836a1.5,1.5,0,0,0-.764-.7A485.065,485.065,0,0,0,404.081,32.03a1.816,1.816,0,0,0-1.923.91,337.461,337.461,0,0,0-14.9,30.6,447.848,447.848,0,0,0-134.426,0,309.541,309.541,0,0,0-15.135-30.6,1.89,1.89,0,0,0-1.924-.91A483.689,483.689,0,0,0,116.085,69.137a1.712,1.712,0,0,0-.788.676C39.068,183.651,18.186,294.69,28.43,404.354a2.016,2.016,0,0,0,.765,1.375A487.666,487.666,0,0,0,176.02,479.918a1.9,1.9,0,0,0,2.063-.676A348.2,348.2,0,0,0,208.12,430.4a1.86,1.86,0,0,0-1.019-2.588,321.173,321.173,0,0,1-45.868-21.853,1.885,1.885,0,0,1-.185-3.126c3.082-2.309,6.166-4.711,9.109-7.137a1.819,1.819,0,0,1,1.9-.256c96.229,43.917,200.41,43.917,295.5,0a1.812,1.812,0,0,1,1.924.233c2.944,2.426,6.027,4.851,9.132,7.16a1.884,1.884,0,0,1-.162,3.126,301.407,301.407,0,0,1-45.89,21.83,1.875,1.875,0,0,0-1,2.611,391.055,391.055,0,0,0,30.014,48.815,1.864,1.864,0,0,0,2.063.7A486.048,486.048,0,0,0,610.7,405.729a1.882,1.882,0,0,0,.765-1.352C623.729,277.594,590.933,167.465,524.531,69.836ZM222.491,337.58c-28.972,0-52.844-26.587-52.844-59.239S193.056,219.1,222.491,219.1c29.665,0,53.306,26.82,52.843,59.239C275.334,310.993,251.924,337.58,222.491,337.58Zm195.38,0c-28.971,0-52.843-26.587-52.843-59.239S388.437,219.1,417.871,219.1c29.667,0,53.307,26.82,52.844,59.239C470.715,310.993,447.538,337.58,417.871,337.58Z"})),Github:React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 24 24",fill:"none",stroke:"var(--icon-fill-color)",strokeWidth:"2",strokeLinecap:"round",strokeLinejoin:"round"},React__namespace.createElement("path",{d:"M15 22v-4a4.8 4.8 0 0 0-1-3.5c3 0 6-2 6-5.5.08-1.25-.27-2.48-1-3.5.28-1.15.28-2.35 0-3.5 0 0-1 0-3 1.5-2.64-.5-5.36-.5-8 0C6 2 5 2 5 2c-.3 1.15-.3 2.35 0 3.5A5.403 5.403 0 0 0 4 9c0 3.5 3 5.5 6 5.5-.39.49-.68 1.05-.85 1.65-.17.6-.22 1.23-.15 1.85v4"}),React__namespace.createElement("path",{d:"M9 18c-4.51 2-5-2-7-2"})),YouTube:React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 24 24",fill:"none",stroke:"var(--icon-fill-color)",strokeWidth:"2",strokeLinecap:"round",strokeLinejoin:"round"},React__namespace.createElement("path",{d:"M12 19c-2.3 0-6.4-.2-8.1-.6-.7-.2-1.2-.7-1.4-1.4-.3-1.1-.5-3.4-.5-5s.2-3.9.5-5c.2-.7.7-1.2 1.4-1.4C5.6 5.2 9.7 5 12 5s6.4.2 8.1.6c.7.2 1.2.7 1.4 1.4.3 1.1.5 3.4.5 5s-.2 3.9-.5 5c-.2.7-.7 1.2-1.4 1.4-1.7.4-5.8.6-8.1.6 0 0 0 0 0 0z"}),React__namespace.createElement("polygon",{points:"10 15 15 12 10 9"})),heart:React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 24 24",fill:"none",stroke:"var(--icon-fill-color)",strokeWidth:"2",strokeLinecap:"round",strokeLinejoin:"round"},React__namespace.createElement("path",{d:"M20.42 4.58a5.4 5.4 0 0 0-7.65 0l-.77.78-.77-.78a5.4 5.4 0 0 0-7.65 0C1.46 6.7 1.33 10.28 4 13l8 8 8-8c2.67-2.72 2.54-6.3.42-8.42z"})),twitter:React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 24 24",fill:"none",stroke:"var(--icon-fill-color)",strokeWidth:"2",strokeLinecap:"round",strokeLinejoin:"round"},React__namespace.createElement("path",{d:"M22 4s-.7 2.1-2 3.4c1.6 10-9.4 17.3-18 11.6 2.2.1 4.4-.6 6-2C3 15.5.5 9.6 3 5c2.2 2.6 5.6 4.1 9 4-.9-4.2 4-6.6 7-3.8 1.1 0 3-1.2 3-1.2z"})),exportLibrary:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 200 190",fill:"var(--icon-fill-color)"},React__namespace.createElement("g",{fillRule:"evenodd"},React__namespace.createElement("path",{strokeWidth:"0",d:"M50 10h20v20H50"}),React__namespace.createElement("path",{fill:"none",stroke:"var(--icon-fill-color)",strokeWidth:"2",d:"M50 10h20m-20 0h20m0 0v20m0-20v20m0 0H50m20 0H50m0 0V10m0 20V10"})),React__namespace.createElement("g",{fillRule:"evenodd"},React__namespace.createElement("path",{strokeWidth:"0",d:"M90 10h20v20H90"}),React__namespace.createElement("path",{fill:"none",stroke:"var(--icon-fill-color)",strokeWidth:"2",d:"M90 10h20m-20 0h20m0 0v20m0-20v20m0 0H90m20 0H90m0 0V10m0 20V10"})),React__namespace.createElement("g",{fillRule:"evenodd"},React__namespace.createElement("path",{strokeWidth:"0",d:"M130 10h20v20h-20"}),React__namespace.createElement("path",{fill:"none",stroke:"var(--icon-fill-color)",strokeWidth:"2",d:"M130 10h20m-20 0h20m0 0v20m0-20v20m0 0h-20m20 0h-20m0 0V10m0 20V10"})),React__namespace.createElement("g",{fillRule:"evenodd"},React__namespace.createElement("path",{strokeWidth:"0",d:"M170 10h20v20h-20"}),React__namespace.createElement("path",{fill:"none",stroke:"var(--icon-fill-color)",strokeWidth:"2",d:"M170 10h20m-20 0h20m0 0v20m0-20v20m0 0h-20m20 0h-20m0 0V10m0 20V10"})),React__namespace.createElement("g",{fillRule:"evenodd"},React__namespace.createElement("path",{strokeWidth:"0",d:"M70 50h60v80h20l-50 50-50-50h20V50"}),React__namespace.createElement("path",{fill:"none",stroke:"var(--icon-fill-color)",strokeWidth:"2",d:"M70 50h60m-60 0h60m0 0v80m0-80v80m0 0h20m-20 0h20m0 0-50 50m50-50-50 50m0 0-50-50m50 50-50-50m0 0h20m-20 0h20m0 0V50m0 80V50m0 0s0 0 0 0m0 0s0 0 0 0m0 0s0 0 0 0m0 0s0 0 0 0"})),React__namespace.createElement("g",{fillRule:"evenodd"},React__namespace.createElement("path",{strokeWidth:"0",d:"M10 10h20v20H10"}),React__namespace.createElement("path",{fill:"none",stroke:"var(--icon-fill-color)",strokeWidth:"2",d:"M10 10h20m-20 0h20m0 0v20m0-20v20m0 0H10m20 0H10m0 0V10m0 20V10"}))),insertPDF:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 512 512",fill:"var(--icon-fill-color)",stroke:"none"},React__namespace.createElement("path",{d:"M64 464H96v48H64c-35.3 0-64-28.7-64-64V64C0 28.7 28.7 0 64 0H229.5c17 0 33.3 6.7 45.3 18.7l90.5 90.5c12 12 18.7 28.3 18.7 45.3V288H336V160H256c-17.7 0-32-14.3-32-32V48H64c-8.8 0-16 7.2-16 16V448c0 8.8 7.2 16 16 16zM176 352h32c30.9 0 56 25.1 56 56s-25.1 56-56 56H192v32c0 8.8-7.2 16-16 16s-16-7.2-16-16V448 368c0-8.8 7.2-16 16-16zm32 80c13.3 0 24-10.7 24-24s-10.7-24-24-24H192v48h16zm96-80h32c26.5 0 48 21.5 48 48v64c0 26.5-21.5 48-48 48H304c-8.8 0-16-7.2-16-16V368c0-8.8 7.2-16 16-16zm32 128c8.8 0 16-7.2 16-16V400c0-8.8-7.2-16-16-16H320v96h16zm80-112c0-8.8 7.2-16 16-16h48c8.8 0 16 7.2 16 16s-7.2 16-16 16H448v32h32c8.8 0 16 7.2 16 16s-7.2 16-16 16H448v48c0 8.8-7.2 16-16 16s-16-7.2-16-16V432 368z"})),insertImage:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 512 512",fill:"var(--icon-fill-color)",stroke:"none"},React__namespace.createElement("path",{d:"M464 64H48C21.49 64 0 85.49 0 112v288c0 26.51 21.49 48 48 48h416c26.51 0 48-21.49 48-48V112c0-26.51-21.49-48-48-48zm-6 336H54a6 6 0 0 1-6-6V118a6 6 0 0 1 6-6h404a6 6 0 0 1 6 6v276a6 6 0 0 1-6 6zM128 152c-22.091 0-40 17.909-40 40s17.909 40 40 40 40-17.909 40-40-17.909-40-40-40zM96 352h320v-80l-87.515-87.515c-4.686-4.686-12.284-4.686-16.971 0L192 304l-39.515-39.515c-4.686-4.686-12.284-4.686-16.971 0L96 304v48z"})),insertMD:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 384 512",fill:"var(--icon-fill-color)",stroke:"none"},React__namespace.createElement("path",{d:"M288 248v28c0 6.6-5.4 12-12 12H108c-6.6 0-12-5.4-12-12v-28c0-6.6 5.4-12 12-12h168c6.6 0 12 5.4 12 12zm-12 72H108c-6.6 0-12 5.4-12 12v28c0 6.6 5.4 12 12 12h168c6.6 0 12-5.4 12-12v-28c0-6.6-5.4-12-12-12zm108-188.1V464c0 26.5-21.5 48-48 48H48c-26.5 0-48-21.5-48-48V48C0 21.5 21.5 0 48 0h204.1C264.8 0 277 5.1 286 14.1L369.9 98c9 8.9 14.1 21.2 14.1 33.9zm-128-80V128h76.1L256 51.9zM336 464V176H232c-13.3 0-24-10.7-24-24V48H48v416h288z"})),insertLaTeX:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 576 512",stroke:"none",fill:"var(--icon-fill-color)",strokeWidth:"20"},React__namespace.createElement("path",{d:"M571.31 251.31l-22.62-22.62c-6.25-6.25-16.38-6.25-22.63 0L480 274.75l-46.06-46.06c-6.25-6.25-16.38-6.25-22.63 0l-22.62 22.62c-6.25 6.25-6.25 16.38 0 22.63L434.75 320l-46.06 46.06c-6.25 6.25-6.25 16.38 0 22.63l22.62 22.62c6.25 6.25 16.38 6.25 22.63 0L480 365.25l46.06 46.06c6.25 6.25 16.38 6.25 22.63 0l22.62-22.62c6.25-6.25 6.25-16.38 0-22.63L525.25 320l46.06-46.06c6.25-6.25 6.25-16.38 0-22.63zM552 0H307.65c-14.54 0-27.26 9.8-30.95 23.87l-84.79 322.8-58.41-106.1A32.008 32.008 0 0 0 105.47 224H24c-13.25 0-24 10.74-24 24v48c0 13.25 10.75 24 24 24h43.62l88.88 163.73C168.99 503.5 186.3 512 204.94 512c17.27 0 44.44-9 54.28-41.48L357.03 96H552c13.25 0 24-10.75 24-24V24c0-13.26-10.75-24-24-24z"})),insertLink:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 512 512",stroke:"none",fill:"var(--icon-fill-color)",strokeWidth:"20"},React__namespace.createElement("path",{d:"M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"})),search:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 512 512",stroke:"var(--icon-fill-color)",fill:"var(--icon-fill-color)",strokeWidth:"20"},React__namespace.createElement("path",{d:"M500.3 443.7l-119.7-119.7c27.22-40.41 40.65-90.9 33.46-144.7C401.8 87.79 326.8 13.32 235.2 1.723C99.01-15.51-15.51 99.01 1.724 235.2c11.6 91.64 86.08 166.7 177.6 178.9c53.8 7.189 104.3-6.236 144.7-33.46l119.7 119.7c15.62 15.62 40.95 15.62 56.57 0C515.9 484.7 515.9 459.3 500.3 443.7zM79.1 208c0-70.58 57.42-128 128-128s128 57.42 128 128c0 70.58-57.42 128-128 128S79.1 278.6 79.1 208z"})),ocr:React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 24 24",fill:"none",stroke:"var(--icon-fill-color)",strokeWidth:"2",strokeLinecap:"round",strokeLinejoin:"round"},React__namespace.createElement("path",{d:"m6 18 6-12 6 12"}),React__namespace.createElement("path",{d:"M8 14h8"}),React__namespace.createElement("path",{d:"M3 7V5a2 2 0 0 1 2-2h2"}),React__namespace.createElement("path",{d:"M17 3h2a2 2 0 0 1 2 2v2"}),React__namespace.createElement("path",{d:"M21 17v2a2 2 0 0 1-2 2h-2"}),React__namespace.createElement("path",{d:"M7 21H5a2 2 0 0 1-2-2v-2"})),scriptEngine:React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 100 100",stroke:"var(--icon-fill-color)",fill:"var(--icon-fill-color)",strokeLinecap:"round",strokeWidth:"4"},React__namespace.createElement("g",{transform:"translate(-8,-8)"},React__namespace.createElement("path",{d:"M24.318 37.983c-1.234-1.232-8.433-3.903-7.401-7.387 1.057-3.484 9.893-12.443 13.669-13.517 3.776-1.074 6.142 6.523 9.012 7.073 2.87.55 6.797-1.572 8.207-3.694 1.384-2.148-3.147-7.413.15-9.168 3.298-1.755 16.389-2.646 19.611-1.284 3.247 1.363-1.611 7.335-.151 9.483 1.46 2.148 6.067 3.746 8.836 3.38 2.769-.368 4.154-6.733 7.728-5.633 3.575 1.1 12.36 8.828 13.67 12.233 1.308 3.406-5.186 5.423-5.79 8.2-.58 2.75-.026 6.705 2.265 8.355 2.266 1.65 9.642-1.78 11.404 1.598 1.762 3.38 1.007 15.35-.806 18.651-1.787 3.353-7.753-.367-9.969 1.31-2.215 1.65-3.901 5.92-3.373 8.67.504 2.777 7.754 4.48 6.445 7.885C96.49 87.543 87.15 95.454 83.5 96.685c-3.65 1.231-4.96-4.741-7.577-5.16-2.593-.393-6.57.707-8.03 2.75-1.436 2.017 2.668 7.806-.63 9.483-3.323 1.676-15.759 2.226-19.157.655-3.373-1.598.554-7.964-1.108-10.138-1.687-2.174-6.394-3.431-9.012-2.907-2.643.55-3.273 7.282-6.747 6.103-3.499-1.126-12.788-9.535-14.172-13.019-1.36-3.484 5.437-5.108 5.966-7.858.529-2.777-.68-7.073-2.744-8.697-2.064-1.624-7.93 2.41-9.642-1.126-1.737-3.537-2.441-16.765-.654-20.118 1.787-3.3 9.062 1.598 11.429.183 2.366-1.44 2.316-7.282 2.769-8.749m.126-.104c-1.234-1.232-8.433-3.903-7.401-7.387 1.057-3.484 9.893-12.443 13.669-13.517 3.776-1.074 6.142 6.523 9.012 7.073 2.87.55 6.797-1.572 8.207-3.694 1.384-2.148-3.147-7.413.15-9.168 3.298-1.755 16.389-2.646 19.611-1.284 3.247 1.363-1.611 7.335-.151 9.483 1.46 2.148 6.067 3.746 8.836 3.38 2.769-.368 4.154-6.733 7.728-5.633 3.575 1.1 12.36 8.828 13.67 12.233 1.308 3.406-5.186 5.423-5.79 8.2-.58 2.75-.026 6.705 2.265 8.355 2.266 1.65 9.642-1.78 11.404 1.598 1.762 3.38 1.007 15.35-.806 18.651-1.787 3.353-7.753-.367-9.969 1.31-2.215 1.65-3.901 5.92-3.373 8.67.504 2.777 7.754 4.48 6.445 7.885C96.49 87.543 87.15 95.454 83.5 96.685c-3.65 1.231-4.96-4.741-7.577-5.16-2.593-.393-6.57.707-8.03 2.75-1.436 2.017 2.668 7.806-.63 9.483-3.323 1.676-15.759 2.226-19.157.655-3.373-1.598.554-7.964-1.108-10.138-1.687-2.174-6.394-3.431-9.012-2.907-2.643.55-3.273 7.282-6.747 6.103-3.499-1.126-12.788-9.535-14.172-13.019-1.36-3.484 5.437-5.108 5.966-7.858.529-2.777-.68-7.073-2.744-8.697-2.064-1.624-7.93 2.41-9.642-1.126-1.737-3.537-2.441-16.765-.654-20.118 1.787-3.3 9.062 1.598 11.429.183 2.366-1.44 2.316-7.282 2.769-8.749",fill:"none",strokeWidth:"2"}),React__namespace.createElement("path",{d:"M81.235 56.502a23.3 23.3 0 0 1-1.46 8.068 20.785 20.785 0 0 1-1.762 3.72 24.068 24.068 0 0 1-5.337 6.26 22.575 22.575 0 0 1-3.449 2.358 23.726 23.726 0 0 1-7.803 2.803 24.719 24.719 0 0 1-8.333 0 24.102 24.102 0 0 1-4.028-1.074 23.71 23.71 0 0 1-3.776-1.729 23.259 23.259 0 0 1-6.369-5.265 23.775 23.775 0 0 1-2.416-3.353 24.935 24.935 0 0 1-1.762-3.72 23.765 23.765 0 0 1-1.083-3.981 23.454 23.454 0 0 1 0-8.173c.252-1.336.604-2.698 1.083-3.956a24.935 24.935 0 0 1 1.762-3.72 22.587 22.587 0 0 1 2.416-3.378c.881-1.048 1.888-2.017 2.946-2.908a24.38 24.38 0 0 1 3.423-2.357 23.71 23.71 0 0 1 3.776-1.73 21.74 21.74 0 0 1 4.028-1.047 23.437 23.437 0 0 1 8.333 0 24.282 24.282 0 0 1 7.803 2.777 26.198 26.198 0 0 1 3.45 2.357 24.62 24.62 0 0 1 5.336 6.287 20.785 20.785 0 0 1 1.762 3.72 21.32 21.32 0 0 1 1.083 3.955c.251 1.336.302 3.405.377 4.086.05.681.05-.68 0 0",fill:"none"}),React__namespace.createElement("path",{d:"M69.404 56.633c-6.596-3.3-13.216-6.6-19.51-9.744m19.51 9.744c-6.747-3.379-13.493-6.758-19.51-9.744m0 0v19.489m0-19.49v19.49m0 0c4.355-2.148 8.71-4.322 19.51-9.745m-19.51 9.745c3.978-1.965 7.93-3.956 19.51-9.745m0 0h0m0 0h0"}))),openLink:React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 24 24",fill:"none",stroke:"var(--icon-fill-color)",strokeWidth:"2",strokeLinecap:"round",strokeLinejoin:"round"},React__namespace.createElement("path",{d:"M4 22h14a2 2 0 0 0 2-2V7.5L14.5 2H6a2 2 0 0 0-2 2v7"}),React__namespace.createElement("polyline",{points:"14 2 14 8 20 8"}),React__namespace.createElement("path",{d:"m10 18 3-3-3-3"}),React__namespace.createElement("path",{d:"M4 18v-1a2 2 0 0 1 2-2h6"})),openLinkProperties:React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 24 24",fill:"none",stroke:"var(--icon-fill-color)",strokeWidth:"3",strokeLinecap:"round",strokeLinejoin:"round"},React__namespace.createElement("path",{d:"M4 22h14a2 2 0 0 0 2-2V7.5L14.5 2H6a2 2 0 0 0-2 2v7"}),React__namespace.createElement("polyline",{points:"14 2 14 8 20 8",fill:"var(--icon-fill-color)"}),React__namespace.createElement("path",{d:"m10 18 3-3-3-3"}),React__namespace.createElement("path",{d:"M4 18v-1a2 2 0 0 1 2-2h6"})),switchToMarkdown:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 640 512",stroke:"var(--icon-fill-color)",strokeWidth:"10",fill:"var(--icon-fill-color)"},React__namespace.createElement("path",{d:"M593.8 59.1H46.2C20.7 59.1 0 79.8 0 105.2v301.5c0 25.5 20.7 46.2 46.2 46.2h547.7c25.5 0 46.2-20.7 46.1-46.1V105.2c0-25.4-20.7-46.1-46.2-46.1zM338.5 360.6H277v-120l-61.5 76.9-61.5-76.9v120H92.3V151.4h61.5l61.5 76.9 61.5-76.9h61.5v209.2zm135.3 3.1L381.5 256H443V151.4h61.5V256H566z"})),gotoFullScreen:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 448 512",stroke:"var(--icon-fill-color)",fill:"var(--icon-fill-color)",strokeWidth:"20"},React__namespace.createElement("path",{d:"M128 32H32C14.31 32 0 46.31 0 64v96c0 17.69 14.31 32 32 32s32-14.31 32-32V96h64c17.69 0 32-14.31 32-32S145.7 32 128 32zM416 32h-96c-17.69 0-32 14.31-32 32s14.31 32 32 32h64v64c0 17.69 14.31 32 32 32s32-14.31 32-32V64C448 46.31 433.7 32 416 32zM128 416H64v-64c0-17.69-14.31-32-32-32s-32 14.31-32 32v96c0 17.69 14.31 32 32 32h96c17.69 0 32-14.31 32-32S145.7 416 128 416zM416 320c-17.69 0-32 14.31-32 32v64h-64c-17.69 0-32 14.31-32 32s14.31 32 32 32h96c17.69 0 32-14.31 32-32v-96C448 334.3 433.7 320 416 320z"})),exitFullScreen:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 448 512",stroke:"var(--icon-fill-color)",fill:"var(--icon-fill-color)",strokeWidth:"20"},React__namespace.createElement("path",{d:"M128 320H32c-17.69 0-32 14.31-32 32s14.31 32 32 32h64v64c0 17.69 14.31 32 32 32s32-14.31 32-32v-96C160 334.3 145.7 320 128 320zM416 320h-96c-17.69 0-32 14.31-32 32v96c0 17.69 14.31 32 32 32s32-14.31 32-32v-64h64c17.69 0 32-14.31 32-32S433.7 320 416 320zM320 192h96c17.69 0 32-14.31 32-32s-14.31-32-32-32h-64V64c0-17.69-14.31-32-32-32s-32 14.31-32 32v96C288 177.7 302.3 192 320 192zM128 32C110.3 32 96 46.31 96 64v64H32C14.31 128 0 142.3 0 160s14.31 32 32 32h96c17.69 0 32-14.31 32-32V64C160 46.31 145.7 32 128 32z"})),releaseNotes:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 512 512",stroke:"var(--icon-fill-color)",fill:"var(--icon-fill-color)",strokeWidth:"20"},React__namespace.createElement("path",{d:"M0 219.2v212.5c0 14.25 11.62 26.25 26.5 27C75.32 461.2 180.2 471.3 240 511.9V245.2C181.4 205.5 79.99 194.8 29.84 192C13.59 191.1 0 203.6 0 219.2zM482.2 192c-50.09 2.848-151.3 13.47-209.1 53.09C272.1 245.2 272 245.3 272 245.5v266.5c60.04-40.39 164.7-50.76 213.5-53.28C500.4 457.9 512 445.9 512 431.7V219.2C512 203.6 498.4 191.1 482.2 192zM352 96c0-53-43-96-96-96S160 43 160 96s43 96 96 96S352 149 352 96z"})),rawMode:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 100 60"},React__namespace.createElement("path",{stroke:"var(--icon-fill-color)",strokeWidth:"4",d:"M20 10H10m10 0H10m0 0v40m0-40v40m0 0h10m-10 0h10M40 10H30m10 0H30m0 0v40m0-40v40m0 0h10m-10 0h10M60 10h10m-10 0h10m0 0v40m0-40v40m0 0H60m10 0H60M80 10h10m-10 0h10m0 0v40m0-40v40m0 0H80m10 0H80"})),parsedMode:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 576 512",stroke:"var(--icon-fill-color)",strokeWidth:"20"},React__namespace.createElement("path",{d:"M574.1 280.4l-45.38-181.8c-5.875-23.63-21.62-44-43-55.75c-21.5-11.75-46.1-14.13-70.25-6.375l-15.25 5.125c-8.375 2.75-12.87 11.88-10 20.25l5 15.13c2.75 8.375 11.88 12.88 20.25 10.13l13.12-4.375c10.88-3.625 23-3.625 33.25 1.75c10.25 5.375 17.5 14.5 20.38 25.75l38.38 153.9c-22.12-6.875-49.75-12.5-81.13-12.5c-34.88 0-73.1 7-114.9 26.75H251.4C210.5 258.6 171.4 251.6 136.5 251.6c-31.38 0-59 5.625-81.12 12.5l38.38-153.9c2.875-11.25 10.12-20.38 20.5-25.75C124.4 79.12 136.5 79.12 147.4 82.74l13.12 4.375c8.375 2.75 17.5-1.75 20.25-10.13l5-15.13C188.6 53.49 184.1 44.37 175.6 41.62l-15.25-5.125c-23.13-7.75-48.75-5.375-70.13 6.375c-21.37 11.75-37.12 32.13-43 55.75L1.875 280.4C.6251 285.4 .0001 290.6 .0001 295.9v70.25C.0001 428.1 51.63 480 115.3 480h37.13c60.25 0 110.4-46 114.9-105.4l2.875-38.63h35.75l2.875 38.63C313.3 433.1 363.4 480 423.6 480h37.13c63.62 0 115.2-51 115.2-113.9V295.9C576 290.6 575.4 285.5 574.1 280.4zM203.4 369.7c-2 26-24.38 46.25-51 46.25H115.2C87 415.1 64 393.6 64 366.1v-37.5c18.12-6.5 43.38-13 72.62-13c23.88 0 47.25 4.375 69.88 13L203.4 369.7zM512 366.1c0 27.5-23 49.88-51.25 49.88h-37.13c-26.62 0-49-20.25-51-46.25l-3.125-41.13c22.62-8.625 46.13-13 70-13c29 0 54.38 6.5 72.5 13V366.1z"})),convertFile:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",viewBox:"0 110 700 340",xmlns:"http://www.w3.org/2000/svg",stroke:"var(--icon-fill-color)",strokeWidth:"20"},React__namespace.createElement("path",{d:"m593.95 239.4v-1.5742c-0.85547-1.8828-2.043-3.6016-3.5-5.0742l-52.5-52.5c-1.4688-1.457-3.1875-2.6445-5.0742-3.5h-1.5742c-1.4727-0.49219-3.0039-0.78516-4.5508-0.875h-124.25c-4.6406 0-9.0938 1.8438-12.375 5.125s-5.125 7.7344-5.125 12.375v87.5h-70v-105.88-1.0508c-0.089844-1.5469-0.38281-3.0781-0.875-4.5508v-1.5742c-0.85547-1.8828-2.043-3.6016-3.5-5.0742l-52.5-52.5c-1.4727-1.457-3.1914-2.6445-5.0742-3.5h-1.5742c-1.7031-0.875-3.5352-1.4688-5.4258-1.75h-123.55c-4.6406 0-9.0938 1.8438-12.375 5.125s-5.125 7.7344-5.125 12.375v245c0 4.6406 1.8438 9.0938 5.125 12.375s7.7344 5.125 12.375 5.125h175c4.6406 0 9.0938-1.8438 12.375-5.125s5.125-7.7344 5.125-12.375v-52.5h70v122.5c0 4.6406 1.8438 9.0938 5.125 12.375s7.7344 5.125 12.375 5.125h175c4.6406 0 9.0938-1.8438 12.375-5.125s5.125-7.7344 5.125-12.375v-192.5-1.0508c-0.14453-1.5547-0.5-3.0859-1.0508-4.5508zm-313.95 110.6h-140v-210h87.5v35c0 4.6406 1.8438 9.0938 5.125 12.375s7.7344 5.125 12.375 5.125h35v87.5h-52.5c-6.2539 0-12.031 3.3359-15.156 8.75s-3.125 12.086 0 17.5 8.9023 8.75 15.156 8.75h52.5zm140 70v-105h27.824l-5.0742 5.0742c-3.7031 3.1719-5.9141 7.7461-6.1055 12.617-0.1875 4.8711 1.668 9.6016 5.1133 13.051 3.4492 3.4453 8.1797 5.3008 13.051 5.1133 4.8711-0.19141 9.4453-2.4023 12.617-6.1055l35-35c3.2578-3.2773 5.0898-7.7148 5.0898-12.336 0-4.625-1.832-9.0586-5.0898-12.34l-35-35c-4.5078-3.8555-10.66-5.1719-16.348-3.4883-5.6875 1.6797-10.137 6.1289-11.816 11.816-1.6836 5.6914-0.37109 11.844 3.4883 16.348l5.0742 5.0742h-27.824v-69.824h87.5v35c0 4.6406 1.8438 9.0938 5.125 12.375s7.7344 5.125 12.375 5.125h35v157.5z"})),cog:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 512 512",fill:"var(--icon-fill-color)",stroke:"none"},React__namespace.createElement("path",{d:"M495.9 166.6C499.2 175.2 496.4 184.9 489.6 191.2L446.3 230.6C447.4 238.9 448 247.4 448 256C448 264.6 447.4 273.1 446.3 281.4L489.6 320.8C496.4 327.1 499.2 336.8 495.9 345.4C491.5 357.3 486.2 368.8 480.2 379.7L475.5 387.8C468.9 398.8 461.5 409.2 453.4 419.1C447.4 426.2 437.7 428.7 428.9 425.9L373.2 408.1C359.8 418.4 344.1 427 329.2 433.6L316.7 490.7C314.7 499.7 307.7 506.1 298.5 508.5C284.7 510.8 270.5 512 255.1 512C241.5 512 227.3 510.8 213.5 508.5C204.3 506.1 197.3 499.7 195.3 490.7L182.8 433.6C167 427 152.2 418.4 138.8 408.1L83.14 425.9C74.3 428.7 64.55 426.2 58.63 419.1C50.52 409.2 43.12 398.8 36.52 387.8L31.84 379.7C25.77 368.8 20.49 357.3 16.06 345.4C12.82 336.8 15.55 327.1 22.41 320.8L65.67 281.4C64.57 273.1 64 264.6 64 256C64 247.4 64.57 238.9 65.67 230.6L22.41 191.2C15.55 184.9 12.82 175.3 16.06 166.6C20.49 154.7 25.78 143.2 31.84 132.3L36.51 124.2C43.12 113.2 50.52 102.8 58.63 92.95C64.55 85.8 74.3 83.32 83.14 86.14L138.8 103.9C152.2 93.56 167 84.96 182.8 78.43L195.3 21.33C197.3 12.25 204.3 5.04 213.5 3.51C227.3 1.201 241.5 0 256 0C270.5 0 284.7 1.201 298.5 3.51C307.7 5.04 314.7 12.25 316.7 21.33L329.2 78.43C344.1 84.96 359.8 93.56 373.2 103.9L428.9 86.14C437.7 83.32 447.4 85.8 453.4 92.95C461.5 102.8 468.9 113.2 475.5 124.2L480.2 132.3C486.2 143.2 491.5 154.7 495.9 166.6V166.6zM256 336C300.2 336 336 300.2 336 255.1C336 211.8 300.2 175.1 256 175.1C211.8 175.1 176 211.8 176 255.1C176 300.2 211.8 336 256 336z"})),trayMode:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 640 512",stroke:"var(--icon-fill-color)",fill:"var(--icon-fill-color)",strokeWidth:"20"},React__namespace.createElement("path",{d:"M618.1 97.67c-13.02-4.375-27.45 .1562-35.72 11.16L464 266.7l-118.4-157.8c-8.266-11.03-22.64-15.56-35.72-11.16C296.8 102 288 114.2 288 128v256c0 17.69 14.33 32 32 32s32-14.31 32-32v-160l86.41 115.2c12.06 16.12 39.13 16.12 51.19 0L576 224v160c0 17.69 14.33 32 32 32s32-14.31 32-32v-256C640 114.2 631.2 102 618.1 97.67zM224 96.01H32c-17.67 0-32 14.31-32 32s14.33 32 32 32h64v223.1c0 17.69 14.33 31.99 32 31.99s32-14.3 32-31.99V160h64c17.67 0 32-14.31 32-32S241.7 96.01 224 96.01z"})),copyElementLink:React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 260 260","aria-hidden":"true",focusable:"false",role:"img"},React__namespace.createElement("path",{stroke:"var(--icon-fill-color)",fill:"none",strokeLinecap:"round",strokeWidth:"8",d:"M10 10h40m-40 0h40m0 0v40m0-40v40m0 0H10m40 0H10m0 0V10m0 40V10M210 10h40m-40 0h40m0 0v40m0-40v40m0 0h-40m40 0h-40m0 0V10m0 40V10M210 210h40m-40 0h40m0 0v40m0-40v40m0 0h-40m40 0h-40m0 0v-40m0 40v-40M10 210h40m-40 0h40m0 0v40m0-40v40m0 0H10m40 0H10m0 0v-40m0 40v-40M30 210V50m0 160V50M50 30h160M50 30h160M230 50v160m0-160v160M50 230h160m-160 0h160"}),React__namespace.createElement("path",{stroke:"var(--icon-fill-color)",fill:"none",strokeLinecap:"round",strokeWidth:"16",d:"M110 90c-6.67 1.67-30 3.11-40 10-10 6.89-20 21.37-20 31.37S60 153.56 70 160c10 6.44 33.33 8.33 40 10m0-80c-6.67 1.67-30 3.11-40 10-10 6.89-20 21.37-20 31.37S60 153.56 70 160c10 6.44 33.33 8.33 40 10M150 90c6.67 1.67 30 3.11 40 10 10 6.89 20 21.37 20 31.37s-10 22.19-20 28.63c-10 6.44-33.33 8.33-40 10m0-80c6.67 1.67 30 3.11 40 10 10 6.89 20 21.37 20 31.37s-10 22.19-20 28.63c-10 6.44-33.33 8.33-40 10"}),React__namespace.createElement("path",{stroke:"var(--icon-fill-color)",fill:"none",strokeLinecap:"round",strokeWidth:"16",d:"M89.868 130.198c13.36-.03 66.78-.17 80.13-.2m-80.13.2c13.36-.03 66.78-.17 80.13-.2"})),importSVG:React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 526 526"},React__namespace.createElement("g",{fillRule:"evenodd",strokeLinecap:"round"},React__namespace.createElement("path",{fill:"var(--input-bg-color)",strokeWidth:"0",d:"m133.462 71 .33-6.54.97-6.34 1.58-6.13 2.16-5.88 2.69-5.6 3.21-5.27 3.69-4.93 4.13-4.55 4.55-4.13 4.93-3.69 5.27-3.21 5.6-2.69 5.88-2.16 6.13-1.58 6.34-.97 6.54-.33h160v128l.16 3.28.49 3.18.79 3.07 1.07 2.94 1.35 2.8 1.6 2.63 1.84 2.47 2.06 2.27 2.27 2.06 2.47 1.84 2.63 1.6 2.8 1.35 2.94 1.07 3.07.79 3.18.49 3.28.16h128v288l-.33 6.54-.97 6.34-1.58 6.13-2.16 5.88-2.69 5.6-3.21 5.27-3.69 4.93-4.13 4.55-4.55 4.13-4.93 3.69-5.27 3.21-5.6 2.69-5.88 2.16-6.13 1.58-6.34.97-6.54.33h-256l-6.54-.33-6.34-.97-6.13-1.58-5.88-2.16-5.6-2.69-5.27-3.21-4.93-3.69-4.55-4.13-4.13-4.55-3.69-4.93-3.21-5.27-2.69-5.6-2.16-5.88-1.58-6.13-.97-6.34-.33-6.54V343h174.1l-39 39-1.65 1.83-1.43 1.94-1.22 2.05-.99 2.13-.77 2.2-.55 2.25-.33 2.29-.11 2.3.11 2.3.33 2.28.55 2.24.77 2.19.99 2.12 1.22 2.04 1.43 1.93 1.65 1.81 1.83 1.64 1.94 1.42 2.05 1.2 2.13.99 2.2.76 2.25.56 2.29.33 2.3.11 2.3-.1 2.28-.33 2.24-.54 2.19-.77 2.12-.98 2.04-1.21 1.93-1.43 1.81-1.65 80-80 1.65-1.83 1.43-1.94 1.22-2.05.99-2.13.77-2.2.55-2.25.33-2.29.11-2.3-.11-2.3-.33-2.28-.55-2.24-.77-2.19-.99-2.12-1.22-2.04-1.43-1.93-1.65-1.81-80-80-1.83-1.65-1.94-1.43-2.05-1.22-2.13-.99-2.2-.77-2.25-.55-2.29-.33-2.3-.11-2.3.11-2.28.33-2.24.55-2.19.77-2.12.99-2.04 1.22-1.93 1.43-1.81 1.65-1.64 1.83-1.42 1.94-1.2 2.05-.99 2.13-.76 2.2-.56 2.25-.33 2.29-.11 2.3.1 2.3.33 2.28.54 2.24.77 2.19.98 2.12 1.21 2.04 1.43 1.93 1.65 1.81 39 39h-174.1V71"}),React__namespace.createElement("path",{fill:"none",stroke:"var(--icon-fill-color)",strokeWidth:"18",d:"M133.462 71s0 0 0 0m0 0s0 0 0 0m0 0 .33-6.54m-.33 6.54c.13-2.57.26-5.13.33-6.54m0 0c.36-2.33.72-4.67.97-6.34m-.97 6.34c.35-2.26.69-4.53.97-6.34m0 0c.51-1.99 1.03-3.98 1.58-6.13m-1.58 6.13c.4-1.56.81-3.12 1.58-6.13m0 0c.81-2.22 1.62-4.43 2.16-5.88m-2.16 5.88c.45-1.22.9-2.44 2.16-5.88m0 0c.72-1.51 1.45-3.01 2.69-5.6m-2.69 5.6c.69-1.45 1.39-2.9 2.69-5.6m0 0c.93-1.52 1.86-3.05 3.21-5.27m-3.21 5.27c.97-1.59 1.94-3.18 3.21-5.27m0 0c.86-1.15 1.71-2.29 3.69-4.93m-3.69 4.93c.78-1.04 1.56-2.08 3.69-4.93m0 0c1.53-1.69 3.07-3.38 4.13-4.55m-4.13 4.55c1.54-1.69 3.07-3.38 4.13-4.55m0 0c1.03-.93 2.06-1.87 4.55-4.13m-4.55 4.13c.98-.89 1.97-1.78 4.55-4.13m0 0c1.64-1.23 3.28-2.46 4.93-3.69m-4.93 3.69c1.72-1.29 3.45-2.58 4.93-3.69m0 0c1.11-.68 2.23-1.35 5.27-3.21m-5.27 3.21c1.5-.91 3.01-1.83 5.27-3.21m0 0c1.87-.89 3.73-1.79 5.6-2.69m-5.6 2.69c2.09-1 4.17-2.01 5.6-2.69m0 0c1.72-.64 3.44-1.27 5.88-2.16m-5.88 2.16c1.94-.72 3.89-1.43 5.88-2.16m0 0c2.3-.59 4.6-1.19 6.13-1.58m-6.13 1.58c2.32-.6 4.65-1.2 6.13-1.58m0 0c2.06-.31 4.12-.63 6.34-.97m-6.34.97c2.34-.36 4.69-.72 6.34-.97m0 0c2.05-.1 4.09-.21 6.54-.33m-6.54.33c2.06-.1 4.12-.21 6.54-.33m0 0h160m-160 0h160m0 0v128m0-128v128m0 0s0 0 0 0m0 0s0 0 0 0m0 0 .16 3.28m-.16-3.28c.06 1.16.12 2.32.16 3.28m0 0c.13.82.26 1.64.49 3.18m-.49-3.18c.18 1.13.35 2.26.49 3.18m0 0c.24.95.49 1.91.79 3.07m-.79-3.07c.28 1.1.56 2.2.79 3.07m0 0c.39 1.06.78 2.13 1.07 2.94m-1.07-2.94c.42 1.15.84 2.3 1.07 2.94m0 0c.38.79.76 1.57 1.35 2.8m-1.35-2.8c.4.82.79 1.64 1.35 2.8m0 0c.45.75.91 1.5 1.6 2.63m-1.6-2.63c.4.65.8 1.31 1.6 2.63m0 0c.56.76 1.13 1.52 1.84 2.47m-1.84-2.47c.58.79 1.17 1.57 1.84 2.47m0 0c.75.82 1.5 1.65 2.06 2.27m-2.06-2.27c.75.82 1.5 1.65 2.06 2.27m0 0c.74.66 1.47 1.33 2.27 2.06m-2.27-2.06c.89.81 1.78 1.61 2.27 2.06m0 0c.69.51 1.37 1.02 2.47 1.84m-2.47-1.84c.68.5 1.35 1.01 2.47 1.84m0 0c.81.49 1.62.99 2.63 1.6m-2.63-1.6c.74.45 1.47.9 2.63 1.6m0 0c.72.35 1.43.69 2.8 1.35m-2.8-1.35c.61.3 1.22.59 2.8 1.35m0 0c.85.31 1.69.62 2.94 1.07m-2.94-1.07c1.03.38 2.07.75 2.94 1.07m0 0c.83.22 1.67.43 3.07.79m-3.07-.79 3.07.79m0 0c1.07.16 2.14.33 3.18.49m-3.18-.49c1.2.18 2.39.36 3.18.49m0 0 3.28.16m-3.28-.16c.97.04 1.93.09 3.28.16m0 0h128m-128 0h128m0 0v288m0-288v288m0 0s0 0 0 0m0 0s0 0 0 0m0 0c-.1 2.02-.2 4.04-.33 6.54m.33-6.54c-.13 2.52-.26 5.05-.33 6.54m0 0c-.33 2.14-.66 4.29-.97 6.34m.97-6.34c-.32 2.06-.63 4.12-.97 6.34m0 0c-.59 2.28-1.17 4.55-1.58 6.13m1.58-6.13c-.53 2.07-1.07 4.14-1.58 6.13m0 0c-.73 1.99-1.46 3.97-2.16 5.88m2.16-5.88c-.72 1.97-1.44 3.94-2.16 5.88m0 0c-.94 1.97-1.89 3.93-2.69 5.6m2.69-5.6c-.91 1.89-1.82 3.77-2.69 5.6m0 0c-.89 1.46-1.78 2.92-3.21 5.27m3.21-5.27c-.65 1.05-1.29 2.11-3.21 5.27m0 0c-1.13 1.51-2.25 3.01-3.69 4.93m3.69-4.93c-1.29 1.72-2.58 3.44-3.69 4.93m0 0c-1.29 1.42-2.58 2.84-4.13 4.55m4.13-4.55-4.13 4.55m0 0-4.55 4.13m4.55-4.13-4.55 4.13m0 0c-1.2.9-2.41 1.8-4.93 3.69m4.93-3.69-4.93 3.69m0 0c-1.56.95-3.13 1.9-5.27 3.21m5.27-3.21c-1.99 1.21-3.98 2.42-5.27 3.21m0 0c-1.8.86-3.6 1.73-5.6 2.69m5.6-2.69c-1.34.64-2.67 1.28-5.6 2.69m0 0c-2.24.82-4.48 1.65-5.88 2.16m5.88-2.16c-1.38.51-2.77 1.02-5.88 2.16m0 0c-1.46.38-2.93.76-6.13 1.58m6.13-1.58c-1.54.4-3.09.79-6.13 1.58m0 0c-2.12.32-4.24.65-6.34.97m6.34-.97c-2.47.38-4.94.75-6.34.97m0 0c-2.23.11-4.46.22-6.54.33m6.54-.33c-1.97.1-3.93.2-6.54.33m0 0h-256m256 0h-256m0 0s0 0 0 0m0 0s0 0 0 0m0 0c-2.33-.12-4.66-.24-6.54-.33m6.54.33c-1.33-.07-2.65-.13-6.54-.33m0 0c-1.88-.29-3.77-.58-6.34-.97m6.34.97c-2.07-.32-4.14-.63-6.34-.97m0 0c-1.52-.39-3.04-.79-6.13-1.58m6.13 1.58c-2.02-.52-4.04-1.04-6.13-1.58m0 0c-1.6-.59-3.19-1.17-5.88-2.16m5.88 2.16c-1.9-.7-3.8-1.39-5.88-2.16m0 0c-1.41-.68-2.82-1.36-5.6-2.69m5.6 2.69c-1.6-.77-3.2-1.54-5.6-2.69m0 0c-1.4-.86-2.81-1.71-5.27-3.21m5.27 3.21c-2.08-1.27-4.17-2.54-5.27-3.21m0 0c-1.72-1.29-3.43-2.57-4.93-3.69m4.93 3.69c-1.79-1.34-3.57-2.67-4.93-3.69m0 0c-1.18-1.07-2.36-2.15-4.55-4.13m4.55 4.13c-1.64-1.49-3.27-2.97-4.55-4.13m0 0c-1.07-1.19-2.15-2.37-4.13-4.55m4.13 4.55c-1.46-1.61-2.93-3.23-4.13-4.55m0 0-3.69-4.93m3.69 4.93c-.88-1.17-1.76-2.35-3.69-4.93m0 0c-.83-1.37-1.67-2.75-3.21-5.27m3.21 5.27c-1.15-1.89-2.3-3.79-3.21-5.27m0 0c-1.03-2.14-2.05-4.27-2.69-5.6m2.69 5.6c-.68-1.43-1.37-2.85-2.69-5.6m0 0c-.8-2.17-1.59-4.34-2.16-5.88m2.16 5.88c-.82-2.22-1.63-4.44-2.16-5.88m0 0c-.47-1.82-.94-3.64-1.58-6.13m1.58 6.13c-.37-1.44-.74-2.88-1.58-6.13m0 0-.97-6.34m.97 6.34c-.3-1.98-.61-3.97-.97-6.34m0 0c-.13-2.54-.26-5.07-.33-6.54m.33 6.54-.33-6.54m0 0V343m0 112V343m0 0h174.1m-174.1 0h174.1m0 0-39 39m39-39-39 39m0 0s0 0 0 0m0 0s0 0 0 0m0 0c-.65.72-1.3 1.44-1.65 1.83m1.65-1.83c-.34.38-.68.76-1.65 1.83m0 0c-.35.47-.7.95-1.43 1.94m1.43-1.94c-.38.5-.75 1.01-1.43 1.94m0 0c-.32.54-.64 1.08-1.22 2.05m1.22-2.05c-.38.64-.76 1.28-1.22 2.05m0 0c-.2.45-.41.89-.99 2.13m.99-2.13c-.38.82-.76 1.64-.99 2.13m0 0c-.18.53-.36 1.05-.77 2.2m.77-2.2c-.3.88-.61 1.75-.77 2.2m0 0c-.15.61-.3 1.22-.55 2.25m.55-2.25c-.16.68-.33 1.35-.55 2.25m0 0-.33 2.29m.33-2.29c-.13.9-.26 1.79-.33 2.29m0 0-.11 2.3m.11-2.3c-.03.59-.06 1.19-.11 2.3m0 0c.03.54.05 1.08.11 2.3m-.11-2.3c.03.72.07 1.44.11 2.3m0 0c.1.71.21 1.43.33 2.28m-.33-2.28c.1.71.21 1.42.33 2.28m0 0c.22.88.44 1.77.55 2.24m-.55-2.24c.16.66.33 1.32.55 2.24m0 0c.26.72.51 1.45.77 2.19m-.77-2.19c.25.69.49 1.39.77 2.19m0 0c.33.7.65 1.4.99 2.12m-.99-2.12c.37.79.74 1.57.99 2.12m0 0c.38.63.75 1.25 1.22 2.04m-1.22-2.04c.4.67.8 1.35 1.22 2.04m0 0c.38.52.77 1.05 1.43 1.93m-1.43-1.93c.38.52.77 1.05 1.43 1.93m0 0c.46.5.91 1 1.65 1.81m-1.65-1.81c.35.39.7.77 1.65 1.81m0 0c.37.33.75.67 1.83 1.64m-1.83-1.64c.43.39.87.78 1.83 1.64m0 0c.62.45 1.25.91 1.94 1.42m-1.94-1.42c.45.32.9.65 1.94 1.42m0 0c.53.3 1.05.61 2.05 1.2m-2.05-1.2c.43.25.86.5 2.05 1.2m0 0c.78.36 1.56.72 2.13.99m-2.13-.99c.54.25 1.08.5 2.13.99m0 0c.67.23 1.33.46 2.2.76m-2.2-.76c.51.17 1.03.35 2.2.76m0 0c.87.22 1.73.43 2.25.56m-2.25-.56c.79.2 1.57.39 2.25.56m0 0 2.29.33m-2.29-.33c.58.08 1.16.16 2.29.33m0 0c.91.04 1.82.09 2.3.11m-2.3-.11c.89.04 1.79.09 2.3.11m0 0c.48-.02.96-.04 2.3-.1m-2.3.1c.73-.03 1.47-.06 2.3-.1m0 0c.61-.09 1.22-.18 2.28-.33m-2.28.33c.58-.09 1.17-.17 2.28-.33m0 0c.79-.19 1.59-.38 2.24-.54m-2.24.54c.88-.21 1.75-.42 2.24-.54m0 0c.7-.25 1.4-.49 2.19-.77m-2.19.77c.5-.18 1.01-.35 2.19-.77m0 0c.56-.26 1.13-.52 2.12-.98m-2.12.98c.69-.31 1.37-.63 2.12-.98m0 0c.63-.37 1.25-.74 2.04-1.21m-2.04 1.21c.8-.48 1.6-.95 2.04-1.21m0 0c.67-.5 1.34-.99 1.93-1.43m-1.93 1.43c.52-.39 1.05-.78 1.93-1.43m0 0c.43-.39.87-.79 1.81-1.65m-1.81 1.65c.42-.38.83-.76 1.81-1.65m0 0 80-80m-80 80 80-80m0 0s0 0 0 0m0 0s0 0 0 0m0 0c.33-.37.67-.74 1.65-1.83m-1.65 1.83c.63-.7 1.27-1.4 1.65-1.83m0 0c.3-.4.59-.79 1.43-1.94m-1.43 1.94c.42-.57.84-1.13 1.43-1.94m0 0c.4-.68.8-1.35 1.22-2.05m-1.22 2.05c.47-.79.93-1.57 1.22-2.05m0 0c.28-.62.57-1.23.99-2.13m-.99 2.13c.3-.65.6-1.31.99-2.13m0 0c.26-.74.51-1.47.77-2.2m-.77 2.2.77-2.2m0 0 .55-2.25m-.55 2.25c.2-.84.41-1.68.55-2.25m0 0 .33-2.29m-.33 2.29c.11-.75.21-1.49.33-2.29m0 0c.03-.54.05-1.08.11-2.3m-.11 2.3c.04-.91.09-1.81.11-2.3m0 0c-.03-.7-.07-1.41-.11-2.3m.11 2.3c-.04-.75-.07-1.49-.11-2.3m0 0c-.08-.52-.15-1.04-.33-2.28m.33 2.28c-.09-.63-.18-1.26-.33-2.28m0 0-.55-2.24m.55 2.24c-.19-.79-.39-1.58-.55-2.24m0 0-.77-2.19m.77 2.19c-.25-.72-.51-1.44-.77-2.19m0 0c-.23-.5-.46-.99-.99-2.12m.99 2.12c-.39-.83-.78-1.66-.99-2.12m0 0c-.42-.7-.83-1.39-1.22-2.04m1.22 2.04c-.32-.53-.64-1.06-1.22-2.04m0 0c-.47-.64-.95-1.28-1.43-1.93m1.43 1.93c-.47-.63-.94-1.27-1.43-1.93m0 0c-.44-.49-.89-.98-1.65-1.81m1.65 1.81c-.64-.7-1.28-1.4-1.65-1.81m0 0-80-80m80 80-80-80m0 0s0 0 0 0m0 0s0 0 0 0m0 0c-.72-.65-1.44-1.3-1.83-1.65m1.83 1.65c-.68-.62-1.37-1.23-1.83-1.65m0 0c-.51-.38-1.02-.75-1.94-1.43m1.94 1.43c-.58-.43-1.17-.87-1.94-1.43m0 0c-.73-.43-1.45-.86-2.05-1.22m2.05 1.22c-.77-.45-1.53-.9-2.05-1.22m0 0c-.46-.21-.93-.43-2.13-.99m2.13.99-2.13-.99m0 0c-.83-.29-1.65-.57-2.2-.77m2.2.77c-.56-.19-1.12-.39-2.2-.77m0 0c-.65-.16-1.29-.31-2.25-.55m2.25.55c-.57-.14-1.13-.27-2.25-.55m0 0c-.74-.11-1.48-.21-2.29-.33m2.29.33c-.51-.07-1.02-.15-2.29-.33m0 0c-.77-.04-1.54-.07-2.3-.11m2.3.11c-.88-.04-1.76-.08-2.3-.11m0 0c-.49.02-.98.05-2.3.11m2.3-.11c-.88.04-1.77.09-2.3.11m0 0c-.62.09-1.23.18-2.28.33m2.28-.33c-.6.09-1.2.17-2.28.33m0 0c-.45.11-.91.22-2.24.55m2.24-.55c-.79.2-1.58.39-2.24.55m0 0c-.56.2-1.12.4-2.19.77m2.19-.77c-.51.18-1.01.36-2.19.77m0 0c-.85.4-1.7.8-2.12.99m2.12-.99c-.51.24-1.02.48-2.12.99m0 0c-.6.36-1.2.71-2.04 1.22m2.04-1.22c-.46.27-.91.55-2.04 1.22m0 0c-.49.36-.99.73-1.93 1.43m1.93-1.43-1.93 1.43m0 0c-.42.38-.85.77-1.81 1.65m1.81-1.65c-.69.63-1.39 1.27-1.81 1.65m0 0-1.64 1.83m1.64-1.83c-.54.6-1.08 1.21-1.64 1.83m0 0c-.53.73-1.07 1.47-1.42 1.94m1.42-1.94c-.36.5-.73 1-1.42 1.94m0 0c-.35.61-.7 1.21-1.2 2.05m1.2-2.05c-.33.58-.67 1.15-1.2 2.05m0 0c-.26.57-.53 1.15-.99 2.13m.99-2.13c-.39.85-.78 1.69-.99 2.13m0 0c-.24.7-.48 1.4-.76 2.2m.76-2.2c-.17.51-.35 1.01-.76 2.2m0 0c-.17.68-.33 1.35-.56 2.25m.56-2.25c-.2.79-.39 1.57-.56 2.25m0 0c-.09.65-.18 1.29-.33 2.29m.33-2.29c-.06.48-.13.95-.33 2.29m0 0c-.03.71-.07 1.43-.11 2.3m.11-2.3-.11 2.3m0 0c.04.86.08 1.73.1 2.3m-.1-2.3c.03.8.07 1.6.1 2.3m0 0c.13.88.25 1.76.33 2.28m-.33-2.28c.11.73.21 1.47.33 2.28m0 0c.18.74.36 1.49.54 2.24m-.54-2.24c.15.64.31 1.28.54 2.24m0 0c.2.57.4 1.15.77 2.19m-.77-2.19c.21.58.41 1.17.77 2.19m0 0c.23.5.46 1.01.98 2.12m-.98-2.12c.35.76.71 1.53.98 2.12m0 0c.38.64.76 1.29 1.21 2.04m-1.21-2.04 1.21 2.04m0 0c.45.6.89 1.21 1.43 1.93m-1.43-1.93c.3.4.6.81 1.43 1.93m0 0 1.65 1.81m-1.65-1.81c.47.52.94 1.03 1.65 1.81m0 0 39 39m-39-39 39 39m0 0h-174.1m174.1 0h-174.1m0 0V71m0 223.9V71m0 0s0 0 0 0m0 0s0 0 0 0m0 0s0 0 0 0m0 0s0 0 0 0"})),React__namespace.createElement("path",{fill:"none",stroke:"var(--icon-fill-color)",strokeLinecap:"round",strokeWidth:"18",d:"M135 343.068H31m104 0H31m0 0s0 0 0 0m0 0s0 0 0 0m0 0c-.74-.04-1.48-.07-2.46-.12m2.46.12c-.77-.04-1.54-.08-2.46-.12m0 0c-.87-.14-1.75-.27-2.39-.37m2.39.37c-.55-.09-1.1-.17-2.39-.37m0 0c-.87-.22-1.74-.44-2.3-.59m2.3.59c-.62-.15-1.24-.31-2.3-.59m0 0c-.82-.29-1.64-.59-2.21-.8m2.21.8c-.52-.18-1.03-.37-2.21-.8m0 0c-.55-.26-1.09-.52-2.1-1.01m2.1 1.01c-.64-.31-1.28-.61-2.1-1.01m0 0c-.74-.45-1.48-.89-1.98-1.2m1.98 1.2c-.42-.25-.84-.51-1.98-1.2m0 0c-.7-.52-1.41-1.05-1.84-1.38m1.84 1.38c-.37-.28-.75-.56-1.84-1.38m0 0c-.4-.36-.8-.71-1.71-1.54m1.71 1.54c-.35-.31-.7-.63-1.71-1.54m0 0c-.43-.47-.85-.95-1.54-1.71m1.54 1.71c-.61-.68-1.23-1.36-1.54-1.71m0 0c-.29-.38-.58-.76-1.38-1.84m1.38 1.84c-.54-.71-1.08-1.43-1.38-1.84m0 0c-.46-.76-.92-1.52-1.2-1.98m1.2 1.98c-.45-.74-.89-1.47-1.2-1.98m0 0c-.37-.77-.74-1.53-1.01-2.1m1.01 2.1c-.3-.62-.6-1.25-1.01-2.1m0 0c-.2-.54-.39-1.07-.8-2.21m.8 2.21c-.2-.54-.4-1.09-.8-2.21m0 0c-.22-.85-.44-1.71-.59-2.3m.59 2.3c-.12-.46-.24-.92-.59-2.3m0 0c-.11-.72-.22-1.43-.37-2.39m.37 2.39c-.08-.48-.15-.96-.37-2.39m0 0c-.03-.74-.07-1.48-.12-2.46m.12 2.46c-.04-.79-.08-1.59-.12-2.46m0 0c.04-.74.07-1.49.12-2.46m-.12 2.46.12-2.46m0 0c.08-.53.16-1.07.37-2.39m-.37 2.39c.09-.56.17-1.12.37-2.39m0 0c.17-.69.35-1.38.59-2.3m-.59 2.3c.15-.61.31-1.23.59-2.3m0 0c.17-.48.34-.96.8-2.21m-.8 2.21c.2-.55.4-1.1.8-2.21m0 0c.25-.52.49-1.03 1.01-2.1m-1.01 2.1c.36-.76.73-1.52 1.01-2.1m0 0c.43-.72.87-1.44 1.2-1.98m-1.2 1.98c.27-.45.55-.91 1.2-1.98m0 0c.54-.73 1.09-1.47 1.38-1.84m-1.38 1.84c.4-.54.81-1.09 1.38-1.84m0 0c.53-.59 1.07-1.18 1.54-1.71m-1.54 1.71c.59-.66 1.19-1.32 1.54-1.71m0 0c.54-.49 1.08-.97 1.71-1.54m-1.71 1.54c.48-.43.95-.86 1.71-1.54m0 0c.46-.35.92-.7 1.84-1.38m-1.84 1.38c.5-.38 1.01-.76 1.84-1.38m0 0c.52-.32 1.04-.63 1.98-1.2m-1.98 1.2c.72-.44 1.44-.88 1.98-1.2m0 0 2.1-1.01m-2.1 1.01c.84-.4 1.67-.81 2.1-1.01m0 0c.45-.17.91-.33 2.21-.8m-2.21.8c.56-.21 1.12-.41 2.21-.8m0 0c.89-.23 1.79-.46 2.3-.59m-2.3.59c.48-.13.95-.25 2.3-.59m0 0c.51-.08 1.02-.16 2.39-.37m-2.39.37 2.39-.37m0 0c.52-.02 1.03-.05 2.46-.12m-2.46.12c.74-.03 1.48-.07 2.46-.12m0 0 103.34-.27m-103.34.27c30.04-.08 60.08-.16 103.34-.27"}),React__namespace.createElement("g",{fillRule:"evenodd",strokeLinecap:"round"},React__namespace.createElement("path",{fill:"var(--input-bg-color)",strokeWidth:"0",d:"M517.462 135h-128V7l128 128"}),React__namespace.createElement("path",{fill:"none",stroke:"var(--icon-fill-color)",strokeWidth:"18",d:"M517.462 135h-128m128 0h-128m0 0V7m0 128V7m0 0 128 128m-128-128 128 128m0 0s0 0 0 0m0 0s0 0 0 0m0 0s0 0 0 0m0 0s0 0 0 0"}))),obsidian:React__namespace.createElement("svg",{focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 512 512"},React__namespace.createElement("defs",null,React__namespace.createElement("radialGradient",{id:"b",cx:"0",cy:"0",r:"1",gradientUnits:"userSpaceOnUse",gradientTransform:"matrix(-48 -185 123 -32 179 429.7)"},React__namespace.createElement("stop",{stopColor:"#fff",stopOpacity:".4"}),React__namespace.createElement("stop",{offset:"1",stopOpacity:".1"})),React__namespace.createElement("radialGradient",{id:"c",cx:"0",cy:"0",r:"1",gradientUnits:"userSpaceOnUse",gradientTransform:"matrix(41 -310 229 30 341.6 351.3)"},React__namespace.createElement("stop",{stopColor:"#fff",stopOpacity:".6"}),React__namespace.createElement("stop",{offset:"1",stopColor:"#fff",stopOpacity:".1"})),React__namespace.createElement("radialGradient",{id:"d",cx:"0",cy:"0",r:"1",gradientUnits:"userSpaceOnUse",gradientTransform:"matrix(57 -261 178 39 190.5 296.3)"},React__namespace.createElement("stop",{stopColor:"#fff",stopOpacity:".8"}),React__namespace.createElement("stop",{offset:"1",stopColor:"#fff",stopOpacity:".4"})),React__namespace.createElement("radialGradient",{id:"e",cx:"0",cy:"0",r:"1",gradientUnits:"userSpaceOnUse",gradientTransform:"matrix(-79 -133 153 -90 321.4 464.2)"},React__namespace.createElement("stop",{stopColor:"#fff",stopOpacity:".3"}),React__namespace.createElement("stop",{offset:"1",stopOpacity:".3"})),React__namespace.createElement("radialGradient",{id:"f",cx:"0",cy:"0",r:"1",gradientUnits:"userSpaceOnUse",gradientTransform:"matrix(-29 136 -92 -20 300.7 149.9)"},React__namespace.createElement("stop",{stopColor:"#fff",stopOpacity:"0"}),React__namespace.createElement("stop",{offset:"1",stopColor:"#fff",stopOpacity:".2"})),React__namespace.createElement("radialGradient",{id:"g",cx:"0",cy:"0",r:"1",gradientUnits:"userSpaceOnUse",gradientTransform:"matrix(72 73 -155 153 137.8 225.2)"},React__namespace.createElement("stop",{stopColor:"#fff",stopOpacity:".2"}),React__namespace.createElement("stop",{offset:"1",stopColor:"#fff",stopOpacity:".4"})),React__namespace.createElement("radialGradient",{id:"h",cx:"0",cy:"0",r:"1",gradientUnits:"userSpaceOnUse",gradientTransform:"matrix(20 118 -251 43 215.1 273.7)"},React__namespace.createElement("stop",{stopColor:"#fff",stopOpacity:".1"}),React__namespace.createElement("stop",{offset:"1",stopColor:"#fff",stopOpacity:".3"})),React__namespace.createElement("radialGradient",{id:"i",cx:"0",cy:"0",r:"1",gradientUnits:"userSpaceOnUse",gradientTransform:"matrix(-162 -85 268 -510 374.4 371.7)"},React__namespace.createElement("stop",{stopColor:"#fff",stopOpacity:".2"}),React__namespace.createElement("stop",{offset:".5",stopColor:"#fff",stopOpacity:".2"}),React__namespace.createElement("stop",{offset:"1",stopColor:"#fff",stopOpacity:".3"})),React__namespace.createElement("filter",{id:"a",x:"80.1",y:"37",width:"351.1",height:"443.2",filterUnits:"userSpaceOnUse",colorInterpolationFilters:"sRGB"},React__namespace.createElement("feFlood",{floodOpacity:"0",result:"BackgroundImageFix"}),React__namespace.createElement("feBlend",{in:"SourceGraphic",in2:"BackgroundImageFix",result:"shape"}),React__namespace.createElement("feGaussianBlur",{stdDeviation:"6.5",result:"effect1_foregroundBlur_744_9191"}))),React__namespace.createElement("g",{filter:"url(#a)"},React__namespace.createElement("path",{d:"M359.2 437.5c-2.6 19-21.3 33.9-40 28.7-26.5-7.2-57.2-18.6-84.8-20.7l-42.4-3.2a28 28 0 0 1-18-8.3l-73-74.8a27.7 27.7 0 0 1-5.4-30.7s45-98.6 46.8-103.7c1.6-5.1 7.8-49.9 11.4-73.9a28 28 0 0 1 9-16.5L249 57.2a28 28 0 0 1 40.6 3.4l72.6 91.6a29.5 29.5 0 0 1 6.2 18.3c0 17.3 1.5 53 11.2 76a301.3 301.3 0 0 0 35.6 58.2 14 14 0 0 1 1 15.6c-6.3 10.7-18.9 31.3-36.6 57.6a142.2 142.2 0 0 0-20.5 59.6Z",fill:"#000",fillOpacity:".3"})),React__namespace.createElement("path",{id:"arrow",d:"M359.9 434.3c-2.6 19.1-21.3 34-40 28.9-26.4-7.3-57-18.7-84.7-20.8l-42.3-3.2a27.9 27.9 0 0 1-18-8.4l-73-75a27.9 27.9 0 0 1-5.4-31s45.1-99 46.8-104.2c1.7-5.1 7.8-50 11.4-74.2a28 28 0 0 1 9-16.6l86.2-77.5a28 28 0 0 1 40.6 3.5l72.5 92a29.7 29.7 0 0 1 6.2 18.3c0 17.4 1.5 53.2 11.1 76.3a303 303 0 0 0 35.6 58.5 14 14 0 0 1 1.1 15.7c-6.4 10.8-18.9 31.4-36.7 57.9a143.3 143.3 0 0 0-20.4 59.8Z",fill:"#6c31e3"}),React__namespace.createElement("path",{d:"M182.7 436.4c33.9-68.7 33-118 18.5-153-13.2-32.4-37.9-52.8-57.3-65.5-.4 1.9-1 3.7-1.8 5.4L96.5 324.8a27.9 27.9 0 0 0 5.5 31l72.9 75c2.3 2.3 5 4.2 7.8 5.6Z",fill:"url(#b)"}),React__namespace.createElement("path",{d:"M274.9 297c9.1.9 18 2.9 26.8 6.1 27.8 10.4 53.1 33.8 74 78.9 1.5-2.6 3-5.1 4.6-7.5a1222 1222 0 0 0 36.7-57.9 14 14 0 0 0-1-15.7 303 303 0 0 1-35.7-58.5c-9.6-23-11-58.9-11.1-76.3 0-6.6-2.1-13.1-6.2-18.3l-72.5-92-1.2-1.5c5.3 17.5 5 31.5 1.7 44.2-3 11.8-8.6 22.5-14.5 33.8-2 3.8-4 7.7-5.9 11.7a140 140 0 0 0-15.8 58c-1 24.2 3.9 54.5 20 95Z",fill:"url(#c)"}),React__namespace.createElement("path",{d:"M274.8 297c-16.1-40.5-21-70.8-20-95 1-24 8-42 15.8-58l6-11.7c5.8-11.3 11.3-22 14.4-33.8a78.5 78.5 0 0 0-1.7-44.2 28 28 0 0 0-39.4-2l-86.2 77.5a28 28 0 0 0-9 16.6L144.2 216c0 .7-.2 1.3-.3 2 19.4 12.6 44 33 57.3 65.3 2.6 6.4 4.8 13.1 6.4 20.4a200 200 0 0 1 67.2-6.8Z",fill:"url(#d)"}),React__namespace.createElement("path",{d:"M320 463.2c18.6 5.1 37.3-9.8 39.9-29a153 153 0 0 1 15.9-52.2c-21-45.1-46.3-68.5-74-78.9-29.5-11-61.6-7.3-94.2.6 7.3 33.1 3 76.4-24.8 132.7 3.1 1.6 6.6 2.5 10.1 2.8l43.9 3.3c23.8 1.7 59.3 14 83.2 20.7Z",fill:"url(#e)"}),React__namespace.createElement("path",{fillRule:"evenodd",clipRule:"evenodd",d:"M255 200.5c-1.1 24 1.9 51.4 18 91.8l-5-.5c-14.5-42.1-17.7-63.7-16.6-88 1-24.3 8.9-43 16.7-59 2-4 6.6-11.5 8.6-15.3 5.8-11.3 9.7-17.2 13-27.5 4.8-14.4 3.8-21.2 3.2-28 3.7 24.5-10.4 45.8-21 67.5a145 145 0 0 0-17 59Z",fill:"url(#f)"}),React__namespace.createElement("path",{fillRule:"evenodd",clipRule:"evenodd",d:"M206 285.1c2 4.4 3.7 8 4.9 13.5l-4.3 1c-1.7-6.4-3-11-5.5-16.5-14.6-34.3-38-52-57-65 23 12.4 46.7 31.9 61.9 67Z",fill:"url(#g)"}),React__namespace.createElement("path",{fillRule:"evenodd",clipRule:"evenodd",d:"M211.1 303c8 37.5-1 85.2-27.5 131.6 22.2-46 33-90.1 24-131l3.5-.7Z",fill:"url(#h)"}),React__namespace.createElement("path",{fillRule:"evenodd",clipRule:"evenodd",d:"M302.7 299.5c43.5 16.3 60.3 52 72.8 81.9-15.5-31.2-37-65.7-74.4-78.5-28.4-9.8-52.4-8.6-93.5.7l-.9-4c43.6-10 66.4-11.2 96 0Z",fill:"url(#i)"})),"add-file":React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 24 24",fill:"none",stroke:"var(--icon-fill-color)",strokeWidth:"2",strokeLinecap:"round",strokeLinejoin:"round"},React__namespace.createElement("path",{d:"M14.5 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7.5L14.5 2z"}),React__namespace.createElement("polyline",{points:"14 2 14 8 20 8"}),React__namespace.createElement("line",{x1:"12",x2:"12",y1:"18",y2:"12"}),React__namespace.createElement("line",{x1:"9",x2:"15",y1:"15",y2:"15"}))},saveIcon=e=>React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 24 24",fill:"none",stroke:e?"var(--color-accent)":"var(--icon-fill-color)",strokeWidth:"2",strokeLinecap:"round",strokeLinejoin:"round"},React__namespace.createElement("path",{d:"M19 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h11l5 5v11a2 2 0 0 1-2 2z"}),React__namespace.createElement("polyline",{points:"17 21 17 13 7 13 7 21"}),React__namespace.createElement("polyline",{points:"7 3 7 8 15 8"})),penIcon=e=>{var t,A,i,n,a,r,s,o,l,c,d,h;switch(e.type){case"highlighter":return React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 24 24",fill:"none",stroke:"var(--icon-fill-color)",strokeWidth:"2",strokeLinecap:"round",strokeLinejoin:"round"},React__namespace.createElement("path",{fill:null!==(t=e.strokeColor)&&void 0!==t?t:"var(--icon-fill-color)",strokeWidth:"2",d:"m9 11-6 6v3h9l3-3"}),React__namespace.createElement("path",{fill:"none",strokeWidth:"2",d:"m22 12-4.6 4.6a2 2 0 0 1-2.8 0l-5.2-5.2a2 2 0 0 1 0-2.8L14 4"}));case"finetip":return React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 24 24",fill:null!==(A=e.strokeColor)&&void 0!==A?A:"var(--icon-fill-color)",stroke:null!==(i=e.strokeColor)&&void 0!==i?i:"var(--icon-fill-color)",strokeWidth:"2",strokeLinecap:"round",strokeLinejoin:"round"},React__namespace.createElement("path",{strokeWidth:"2",d:"M17 3a2.828 2.828 0 1 1 4 4L7.5 20.5 2 22l1.5-5.5L17 3z"}));case"fountain":return React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 24 24",fill:"none",stroke:"var(--icon-fill-color)",strokeWidth:"2",strokeLinecap:"round",strokeLinejoin:"round"},React__namespace.createElement("path",{fill:null!==(n=e.strokeColor)&&void 0!==n?n:"var(--icon-fill-color)",d:"m12 19 7-7 3 3-7 7-3-3z"}),React__namespace.createElement("path",{fill:"none",d:"m18 13-1.5-7.5L2 2l3.5 14.5L13 18l5-5z"}),React__namespace.createElement("path",{fill:"none",d:"m2 2 7.586 7.586"}),React__namespace.createElement("circle",{fill:"none",cx:"11",cy:"11",r:"2"}));case"marker":return React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 576 512",fill:null!==(a=e.strokeColor)&&void 0!==a?a:"var(--icon-fill-color)",stroke:null!==(r=e.strokeColor)&&void 0!==r?r:"var(--icon-fill-color)",strokeWidth:"2",strokeLinecap:"round",strokeLinejoin:"round"},React__namespace.createElement("path",{d:"M331 315l158.4-215L460.1 70.6 245 229 331 315zm-187 5l0 0V248.3c0-15.3 7.2-29.6 19.5-38.6L436.6 8.4C444 2.9 453 0 462.2 0c11.4 0 22.4 4.5 30.5 12.6l54.8 54.8c8.1 8.1 12.6 19 12.6 30.5c0 9.2-2.9 18.2-8.4 25.6L350.4 396.5c-9 12.3-23.4 19.5-38.6 19.5H240l-25.4 25.4c-12.5 12.5-32.8 12.5-45.3 0l-50.7-50.7c-12.5-12.5-12.5-32.8 0-45.3L144 320zM23 466.3l63-63 70.6 70.6-31 31c-4.5 4.5-10.6 7-17 7H40c-13.3 0-24-10.7-24-24v-4.7c0-6.4 2.5-12.5 7-17z"}));case"thick-thin":return React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 108 106",strokeWidth:"2",fill:null!==(s=e.strokeColor)&&void 0!==s?s:"var(--icon-fill-color)",stroke:null!==(o=e.strokeColor)&&void 0!==o?o:"var(--icon-fill-color)"},React__namespace.createElement("path",{d:"m-.58 95.628.22-.89q.22-.89.49-2.44.26-1.54.77-3.35t1.31-3.43q.79-1.61.2-.26-.6 1.34-.03-.14.58-1.49 1.54-2.97.96-1.49 2.54-3.18 1.59-1.68 3.46-2.96 1.86-1.27.81-.54-1.04.73.6-.46 1.64-1.19 2.8-1.81 1.16-.63.16-.08-.99.54 1.21-.5 2.2-1.03 1.11-.58-1.1.45-.03-.07 1.06-.53 2.32-.82 1.26-.3 2.91-.52 1.64-.23 3.05-.18 1.4.05 2.5.12 1.09.07 2.25.24 1.16.17 2.3.49 1.15.32 2.11.78.96.47 2.21 1.01 1.25.55 2.37 1.04t2.34.89q1.22.4 2.5.65 1.29.25 2.44.33 1.16.08 2.35.17 1.18.08 2.26-.1 1.08-.19 2-1.1.92-.91 1.25-1.93.32-1.02.38-2.15t.57.21q.51 1.34-.03-.02-.55-1.37-.96-2.83-.41-1.45.5-.67.92.79-.03-.06-.95-.85-1.52-1.8-.57-.94-1.5-1.52-.93-.57-1.94-1.22-1.01-.65-1.97-1.88-.96-1.22-1.44-2.54-.49-1.32-.65-2.57-.17-1.24-.11-2.35.06-1.11.31-2.91.24-1.79.76-2.77.51-.97 1.29-1.8.77-.84 1.64-1.55.88-.72 1.9-1.33 1.03-.61 2.43-1.15 1.41-.55 2.69-.92 1.29-.37 2.81-.68 1.53-.31 2.83-.58 1.31-.27 2.78-.47 1.47-.2 2.58-.49 1.12-.28 2.19-.58 1.08-.31 2.13-.73 1.05-.42 2.44-1.32 1.39-.9 2.68-1.85 1.3-.95 2.25-1.87.95-.91 2.06-2 1.11-1.09 1.92-1.93.82-.84 1.54-1.82.71-.98 1.4-1.88.69-.9 1.38-1.96.69-1.07 1.25-2.04.55-.97 1.21-1.94.65-.96 1.35-1.79.69-.83 1.46-1.74.77-.9 1.66-1.73.89-.84 2.72-2.31 1.84-1.48 1.84-1.47v.01l-1.1 1.03q-1.1 1.02-1.77 1.92-.68.9-1.39 1.85-.71.96-1.41 1.91-.7.96-1.19 1.92-.48.95-.95 1.92-.46.96-.9 1.95-.43.99-1.02 2.16-.59 1.17-1.17 2.15-.58.97-1.23 2.13t-1.29 2.02q-.64.86-1.3 1.73-.66.88-1.42 1.78-.75.9-1.72 2.03-.97 1.14-1.81 1.89-.85.75-1.98 1.71-1.14.96-2.05 1.61-.91.64-2.42 1.38-1.51.73-2.71 1.21t-2.49.92q-1.3.44-2.35.69-1.06.24-2.1.59-1.03.34-2.06.74-1.03.4-2.29.94-1.26.54-2.27 1.11-1.01.58-1.57 1.57-.56.99-.81 2.06-.25 1.08.56 2.02.8.94-.21-.02-1.02-.96-.01-.48 1 .49 1.87 1.25.87.77 0 0-.88-.77.46-.01 1.34.75 2.6 1.68 1.26.94 2.08 2.03.81 1.09.01.27-.8-.82.3.26 1.11 1.08 1.71 2.1.61 1.02 1.21 2.25.6 1.24.92 2.36.32 1.12-.16.13-.49-.98.02.36.51 1.35.71 2.69.2 1.34.24 2.46.03 1.12-.09 2.42-.13 1.29-.72 3.21-.6 1.92-1.4 3.49-.81 1.58-1.77 2.83-.96 1.24-2.88 2.72-1.92 1.48-2.95 1.85-1.04.36-2.47.76-1.44.41-3.33.72-1.89.32-3.37.41-1.48.09-2.63.15-1.15.05-2.74-.06-1.59-.1-2.8-.29-1.2-.19-3.2-.63-1.99-.45-3.63-.92-1.63-.48-3.28-.79-1.65-.31-2.76-.2-1.11.1-2.21.42-1.11.32.39-.29 1.49-.6-.12.21-1.61.8-.39.19 1.21-.61.29.13-.92.74-1.83 1.34-.92.61.15-.19t.3-.05q-.77.75-1.58 1.57-.81.82.01-.18.82-1 .24.23t-.72 2.72q-.15 1.48-.08 2.4.07.91-.19 2.16-.26 1.26-.81 2.41-.55 1.16-1.36 2.15t-1.84 1.75q-1.03.77-2.21 1.27t-2.44.7q-1.27.2-2.53.1-1.28-.11-2.49-.52-1.22-.41-2.3-1.1-1.08-.68-1.96-1.61-.89-.92-1.52-2.04-.64-1.11-.99-2.34-.36-1.23-.41-2.51l-.04-1.27Z"}));case"thin-thick-thin":return React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 114 113",strokeWidth:"2",fill:null!==(l=e.strokeColor)&&void 0!==l?l:"var(--icon-fill-color)",stroke:null!==(c=e.strokeColor)&&void 0!==c?c:"var(--icon-fill-color)"},React__namespace.createElement("path",{d:"m10 103.405.13-1.22q.14-1.22 1.3-3.16 1.15-1.94 2.74-3.46 1.59-1.53 3.35-2.72 1.77-1.2 4-1.95 2.23-.76 4.45-1t4.86-.4q2.64-.15 5.14-.34 2.51-.19 4.85-.94 2.35-.75 4.55-1.71 2.21-.97 4.16-2.26 1.95-1.3 4.03-2.97 2.07-1.67 3.85-3.05 1.78-1.37 3.72-2.48 1.94-1.11 3.3-2.99 1.36-1.89 2.58-3.74 1.22-1.85-.63-3.42-1.85-1.57-3.82-2.86-1.97-1.3-4.11-2.08-2.15-.78-4.21-1.6-2.06-.81-4.02-1.96-1.96-1.14-3.71-2.48-1.74-1.33-3.37-2.77-1.63-1.43-3.23-3.62-1.6-2.18-2.23-4.64-.62-2.46-.36-4.96.27-2.49 1.19-4.46.91-1.97 2.42-3.7 1.5-1.73 3.5-3.15t4.11-2.28q2.1-.86 4.33-1.44 2.24-.58 4.92-.84 2.68-.26 4.83-.19t4.69.35q2.53.28 4.75.66 2.23.38 4.48.2 2.26-.19 4.43-1.3 2.17-1.12 4.2-2.36 2.04-1.24 3.93-2.43 1.9-1.19 3.84-2.14 1.95-.95 4.04-1.78 2.09-.83 4.56-2.28 2.46-1.46 2.46-1.45h.01q.01 0-1.38 1.3-1.38 1.29-3.08 2.59-1.7 1.3-3.5 2.5t-3.42 2.65q-1.62 1.45-3.18 3-1.57 1.56-3.37 3.13-1.8 1.57-3.6 2.91-1.81 1.33-3.92 2.12t-4.24.92q-2.13.14-4.31.26-2.18.12-4.5.39t-4.56.88q-2.25.61-4.24 1.6-1.99 1-3.83 2.29-1.83 1.29.18 2.44 2.01 1.15 4.2 1.92 2.2.78 4.34 1 2.15.22 4.4.69 2.25.46 4.34 1.16 2.08.71 4.33 1.91 2.25 1.21 4.11 2.73 1.87 1.52 3.68 4.03 1.82 2.5 2.74 5 .93 2.5 1.18 5.03.26 2.53-.04 4.81t-1.4 4.85q-1.09 2.58-2.4 4.26-1.3 1.68-3.1 3.44t-4.02 3.62q-2.23 1.85-4.32 3.07-2.08 1.23-4.34 1.99-2.25.76-4.46 1.96t-4.37 2.14q-2.15.93-4.22 1.81t-4.36 1.35q-2.3.46-4.52.82-2.22.35-4.76.38-2.54.04-4.87-.28t-4.67-.67q-2.34-.35-4.72-.54-2.39-.19-4.64.37-2.25.56-4.16 1.66-1.91 1.11-3.52 2.71-1.61 1.6-2.55 2.39l-.94.78Z"}));default:return React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 512 512",fill:null!==(d=e.strokeColor)&&void 0!==d?d:"var(--icon-fill-color)",stroke:null!==(h=e.strokeColor)&&void 0!==h?h:"var(--icon-fill-color)",strokeWidth:"2",strokeLinecap:"round",strokeLinejoin:"round"},React__namespace.createElement("path",{d:"M453.3 19.3l39.4 39.4c25 25 25 65.5 0 90.5l-52.1 52.1 0 0-1-1 0 0-16-16-96-96-17-17 52.1-52.1c25-25 65.5-25 90.5 0zM241 114.9c-9.4-9.4-24.6-9.4-33.9 0L105 217c-9.4 9.4-24.6 9.4-33.9 0s-9.4-24.6 0-33.9L173.1 81c28.1-28.1 73.7-28.1 101.8 0L288 94.1l17 17 96 96 16 16 1 1-17 17L229.5 412.5c-48 48-109.2 80.8-175.8 94.1l-25 5c-7.9 1.6-16-.9-21.7-6.6s-8.1-13.8-6.6-21.7l5-25c13.3-66.6 46.1-127.8 94.1-175.8L254.1 128 241 114.9z"}))}},stringToSVG=e=>(e=e.replace(/stroke\s*=\s*['"][^"']*['"]/g,"").replace(/[^-]width\s*=\s*['"][^"']*['"]/g,"").replace(/[^-]height\s*=\s*['"][^"']*['"]/g,"").replace("0&&round(i.width)/e.offsetWidth||1,a=e.offsetHeight>0&&round(i.height)/e.offsetHeight||1);var r=(isElement(e)?getWindow(e):window).visualViewport,s=!isLayoutViewport()&&A,o=(i.left+(s&&r?r.offsetLeft:0))/n,l=(i.top+(s&&r?r.offsetTop:0))/a,c=i.width/n,d=i.height/a;return{width:c,height:d,top:l,right:o+c,bottom:l+d,left:o,x:o,y:l}}function getLayoutRect(e){var t=getBoundingClientRect(e),A=e.offsetWidth,i=e.offsetHeight;return Math.abs(t.width-A)<=1&&(A=t.width),Math.abs(t.height-i)<=1&&(i=t.height),{x:e.offsetLeft,y:e.offsetTop,width:A,height:i}}function contains(e,t){var A=t.getRootNode&&t.getRootNode();if(e.contains(t))return!0;if(A&&isShadowRoot(A)){var i=t;do{if(i&&e.isSameNode(i))return!0;i=i.parentNode||i.host}while(i)}return!1}function getComputedStyle$1(e){return getWindow(e).getComputedStyle(e)}function isTableElement(e){return["table","td","th"].indexOf(getNodeName(e))>=0}function getDocumentElement(e){return((isElement(e)?e.ownerDocument:e.document)||window.document).documentElement}function getParentNode(e){return"html"===getNodeName(e)?e:e.assignedSlot||e.parentNode||(isShadowRoot(e)?e.host:null)||getDocumentElement(e)}function getTrueOffsetParent(e){return isHTMLElement(e)&&"fixed"!==getComputedStyle$1(e).position?e.offsetParent:null}function getContainingBlock(e){var t=/firefox/i.test(getUAString());if(/Trident/i.test(getUAString())&&isHTMLElement(e)&&"fixed"===getComputedStyle$1(e).position)return null;var A=getParentNode(e);for(isShadowRoot(A)&&(A=A.host);isHTMLElement(A)&&["html","body"].indexOf(getNodeName(A))<0;){var i=getComputedStyle$1(A);if("none"!==i.transform||"none"!==i.perspective||"paint"===i.contain||-1!==["transform","perspective"].indexOf(i.willChange)||t&&"filter"===i.willChange||t&&i.filter&&"none"!==i.filter)return A;A=A.parentNode}return null}function getOffsetParent(e){for(var t=getWindow(e),A=getTrueOffsetParent(e);A&&isTableElement(A)&&"static"===getComputedStyle$1(A).position;)A=getTrueOffsetParent(A);return A&&("html"===getNodeName(A)||"body"===getNodeName(A)&&"static"===getComputedStyle$1(A).position)?t:A||getContainingBlock(e)||t}function getMainAxisFromPlacement(e){return["top","bottom"].indexOf(e)>=0?"x":"y"}function within(e,t,A){return max(e,min(t,A))}function withinMaxClamp(e,t,A){var i=within(e,t,A);return i>A?A:i}function getFreshSideObject(){return{top:0,right:0,bottom:0,left:0}}function mergePaddingObject(e){return Object.assign({},getFreshSideObject(),e)}function expandToHashMap(e,t){return t.reduce((function(t,A){return t[A]=e,t}),{})}var toPaddingObject=function(e,t){return mergePaddingObject("number"!=typeof(e="function"==typeof e?e(Object.assign({},t.rects,{placement:t.placement})):e)?e:expandToHashMap(e,basePlacements))};function arrow(e){var t,A=e.state,i=e.name,n=e.options,a=A.elements.arrow,r=A.modifiersData.popperOffsets,s=getBasePlacement(A.placement),o=getMainAxisFromPlacement(s),l=[left,right].indexOf(s)>=0?"height":"width";if(a&&r){var c=toPaddingObject(n.padding,A),d=getLayoutRect(a),h="y"===o?top:left,u="y"===o?bottom:right,g=A.rects.reference[l]+A.rects.reference[o]-r[o]-A.rects.popper[l],p=r[o]-A.rects.reference[o],m=getOffsetParent(a),w=m?"y"===o?m.clientHeight||0:m.clientWidth||0:0,f=g/2-p/2,E=c[h],B=w-d[l]-c[u],b=w/2-d[l]/2+f,v=within(E,b,B),C=o;A.modifiersData[i]=((t={})[C]=v,t.centerOffset=v-b,t)}}function effect$1(e){var t=e.state,A=e.options.element,i=void 0===A?"[data-popper-arrow]":A;null!=i&&("string"!=typeof i||(i=t.elements.popper.querySelector(i)))&&contains(t.elements.popper,i)&&(t.elements.arrow=i)}var arrow$1={name:"arrow",enabled:!0,phase:"main",fn:arrow,effect:effect$1,requires:["popperOffsets"],requiresIfExists:["preventOverflow"]};function getVariation(e){return e.split("-")[1]}var unsetSides={top:"auto",right:"auto",bottom:"auto",left:"auto"};function roundOffsetsByDPR(e){var t=e.x,A=e.y,i=window.devicePixelRatio||1;return{x:round(t*i)/i||0,y:round(A*i)/i||0}}function mapToStyles(e){var t,A=e.popper,i=e.popperRect,n=e.placement,a=e.variation,r=e.offsets,s=e.position,o=e.gpuAcceleration,l=e.adaptive,c=e.roundOffsets,d=e.isFixed,h=r.x,u=void 0===h?0:h,g=r.y,p=void 0===g?0:g,m="function"==typeof c?c({x:u,y:p}):{x:u,y:p};u=m.x,p=m.y;var w=r.hasOwnProperty("x"),f=r.hasOwnProperty("y"),E=left,B=top,b=window;if(l){var v=getOffsetParent(A),C="clientHeight",y="clientWidth";v===getWindow(A)&&"static"!==getComputedStyle$1(v=getDocumentElement(A)).position&&"absolute"===s&&(C="scrollHeight",y="scrollWidth"),v=v,(n===top||(n===left||n===right)&&a===end)&&(B=bottom,p-=(d&&v===b&&b.visualViewport?b.visualViewport.height:v[C])-i.height,p*=o?1:-1),n!==left&&(n!==top&&n!==bottom||a!==end)||(E=right,u-=(d&&v===b&&b.visualViewport?b.visualViewport.width:v[y])-i.width,u*=o?1:-1)}var F,x=Object.assign({position:s},l&&unsetSides),S=!0===c?roundOffsetsByDPR({x:u,y:p}):{x:u,y:p};return u=S.x,p=S.y,o?Object.assign({},x,((F={})[B]=f?"0":"",F[E]=w?"0":"",F.transform=(b.devicePixelRatio||1)<=1?"translate("+u+"px, "+p+"px)":"translate3d("+u+"px, "+p+"px, 0)",F)):Object.assign({},x,((t={})[B]=f?p+"px":"",t[E]=w?u+"px":"",t.transform="",t))}function computeStyles(e){var t=e.state,A=e.options,i=A.gpuAcceleration,n=void 0===i||i,a=A.adaptive,r=void 0===a||a,s=A.roundOffsets,o=void 0===s||s,l={placement:getBasePlacement(t.placement),variation:getVariation(t.placement),popper:t.elements.popper,popperRect:t.rects.popper,gpuAcceleration:n,isFixed:"fixed"===t.options.strategy};null!=t.modifiersData.popperOffsets&&(t.styles.popper=Object.assign({},t.styles.popper,mapToStyles(Object.assign({},l,{offsets:t.modifiersData.popperOffsets,position:t.options.strategy,adaptive:r,roundOffsets:o})))),null!=t.modifiersData.arrow&&(t.styles.arrow=Object.assign({},t.styles.arrow,mapToStyles(Object.assign({},l,{offsets:t.modifiersData.arrow,position:"absolute",adaptive:!1,roundOffsets:o})))),t.attributes.popper=Object.assign({},t.attributes.popper,{"data-popper-placement":t.placement})}var computeStyles$1={name:"computeStyles",enabled:!0,phase:"beforeWrite",fn:computeStyles,data:{}},passive={passive:!0};function effect(e){var t=e.state,A=e.instance,i=e.options,n=i.scroll,a=void 0===n||n,r=i.resize,s=void 0===r||r,o=getWindow(t.elements.popper),l=[].concat(t.scrollParents.reference,t.scrollParents.popper);return a&&l.forEach((function(e){e.addEventListener("scroll",A.update,passive)})),s&&o.addEventListener("resize",A.update,passive),function(){a&&l.forEach((function(e){e.removeEventListener("scroll",A.update,passive)})),s&&o.removeEventListener("resize",A.update,passive)}}var eventListeners={name:"eventListeners",enabled:!0,phase:"write",fn:function(){},effect:effect,data:{}},hash$1={left:"right",right:"left",bottom:"top",top:"bottom"};function getOppositePlacement(e){return e.replace(/left|right|bottom|top/g,(function(e){return hash$1[e]}))}var hash={start:"end",end:"start"};function getOppositeVariationPlacement(e){return e.replace(/start|end/g,(function(e){return hash[e]}))}function getWindowScroll(e){var t=getWindow(e);return{scrollLeft:t.pageXOffset,scrollTop:t.pageYOffset}}function getWindowScrollBarX(e){return getBoundingClientRect(getDocumentElement(e)).left+getWindowScroll(e).scrollLeft}function getViewportRect(e,t){var A=getWindow(e),i=getDocumentElement(e),n=A.visualViewport,a=i.clientWidth,r=i.clientHeight,s=0,o=0;if(n){a=n.width,r=n.height;var l=isLayoutViewport();(l||!l&&"fixed"===t)&&(s=n.offsetLeft,o=n.offsetTop)}return{width:a,height:r,x:s+getWindowScrollBarX(e),y:o}}function getDocumentRect(e){var t,A=getDocumentElement(e),i=getWindowScroll(e),n=null==(t=e.ownerDocument)?void 0:t.body,a=max(A.scrollWidth,A.clientWidth,n?n.scrollWidth:0,n?n.clientWidth:0),r=max(A.scrollHeight,A.clientHeight,n?n.scrollHeight:0,n?n.clientHeight:0),s=-i.scrollLeft+getWindowScrollBarX(e),o=-i.scrollTop;return"rtl"===getComputedStyle$1(n||A).direction&&(s+=max(A.clientWidth,n?n.clientWidth:0)-a),{width:a,height:r,x:s,y:o}}function isScrollParent(e){var t=getComputedStyle$1(e),A=t.overflow,i=t.overflowX,n=t.overflowY;return/auto|scroll|overlay|hidden/.test(A+n+i)}function getScrollParent(e){return["html","body","#document"].indexOf(getNodeName(e))>=0?e.ownerDocument.body:isHTMLElement(e)&&isScrollParent(e)?e:getScrollParent(getParentNode(e))}function listScrollParents(e,t){var A;void 0===t&&(t=[]);var i=getScrollParent(e),n=i===(null==(A=e.ownerDocument)?void 0:A.body),a=getWindow(i),r=n?[a].concat(a.visualViewport||[],isScrollParent(i)?i:[]):i,s=t.concat(r);return n?s:s.concat(listScrollParents(getParentNode(r)))}function rectToClientRect(e){return Object.assign({},e,{left:e.x,top:e.y,right:e.x+e.width,bottom:e.y+e.height})}function getInnerBoundingClientRect(e,t){var A=getBoundingClientRect(e,!1,"fixed"===t);return A.top=A.top+e.clientTop,A.left=A.left+e.clientLeft,A.bottom=A.top+e.clientHeight,A.right=A.left+e.clientWidth,A.width=e.clientWidth,A.height=e.clientHeight,A.x=A.left,A.y=A.top,A}function getClientRectFromMixedType(e,t,A){return t===viewport?rectToClientRect(getViewportRect(e,A)):isElement(t)?getInnerBoundingClientRect(t,A):rectToClientRect(getDocumentRect(getDocumentElement(e)))}function getClippingParents(e){var t=listScrollParents(getParentNode(e)),A=["absolute","fixed"].indexOf(getComputedStyle$1(e).position)>=0&&isHTMLElement(e)?getOffsetParent(e):e;return isElement(A)?t.filter((function(e){return isElement(e)&&contains(e,A)&&"body"!==getNodeName(e)})):[]}function getClippingRect(e,t,A,i){var n="clippingParents"===t?getClippingParents(e):[].concat(t),a=[].concat(n,[A]),r=a[0],s=a.reduce((function(t,A){var n=getClientRectFromMixedType(e,A,i);return t.top=max(n.top,t.top),t.right=min(n.right,t.right),t.bottom=min(n.bottom,t.bottom),t.left=max(n.left,t.left),t}),getClientRectFromMixedType(e,r,i));return s.width=s.right-s.left,s.height=s.bottom-s.top,s.x=s.left,s.y=s.top,s}function computeOffsets(e){var t,A=e.reference,i=e.element,n=e.placement,a=n?getBasePlacement(n):null,r=n?getVariation(n):null,s=A.x+A.width/2-i.width/2,o=A.y+A.height/2-i.height/2;switch(a){case top:t={x:s,y:A.y-i.height};break;case bottom:t={x:s,y:A.y+A.height};break;case right:t={x:A.x+A.width,y:o};break;case left:t={x:A.x-i.width,y:o};break;default:t={x:A.x,y:A.y}}var l=a?getMainAxisFromPlacement(a):null;if(null!=l){var c="y"===l?"height":"width";switch(r){case start:t[l]=t[l]-(A[c]/2-i[c]/2);break;case end:t[l]=t[l]+(A[c]/2-i[c]/2)}}return t}function detectOverflow(e,t){void 0===t&&(t={});var A=t,i=A.placement,n=void 0===i?e.placement:i,a=A.strategy,r=void 0===a?e.strategy:a,s=A.boundary,o=void 0===s?clippingParents:s,l=A.rootBoundary,c=void 0===l?viewport:l,d=A.elementContext,h=void 0===d?popper:d,u=A.altBoundary,g=void 0!==u&&u,p=A.padding,m=void 0===p?0:p,w=mergePaddingObject("number"!=typeof m?m:expandToHashMap(m,basePlacements)),f=h===popper?reference:popper,E=e.rects.popper,B=e.elements[g?f:h],b=getClippingRect(isElement(B)?B:B.contextElement||getDocumentElement(e.elements.popper),o,c,r),v=getBoundingClientRect(e.elements.reference),C=computeOffsets({reference:v,element:E,strategy:"absolute",placement:n}),y=rectToClientRect(Object.assign({},E,C)),F=h===popper?y:v,x={top:b.top-F.top+w.top,bottom:F.bottom-b.bottom+w.bottom,left:b.left-F.left+w.left,right:F.right-b.right+w.right},S=e.modifiersData.offset;if(h===popper&&S){var T=S[n];Object.keys(x).forEach((function(e){var t=[right,bottom].indexOf(e)>=0?1:-1,A=[top,bottom].indexOf(e)>=0?"y":"x";x[e]+=T[A]*t}))}return x}function computeAutoPlacement(e,t){void 0===t&&(t={});var A=t,i=A.placement,n=A.boundary,a=A.rootBoundary,r=A.padding,s=A.flipVariations,o=A.allowedAutoPlacements,l=void 0===o?placements:o,c=getVariation(i),d=c?s?variationPlacements:variationPlacements.filter((function(e){return getVariation(e)===c})):basePlacements,h=d.filter((function(e){return l.indexOf(e)>=0}));0===h.length&&(h=d);var u=h.reduce((function(t,A){return t[A]=detectOverflow(e,{placement:A,boundary:n,rootBoundary:a,padding:r})[getBasePlacement(A)],t}),{});return Object.keys(u).sort((function(e,t){return u[e]-u[t]}))}function getExpandedFallbackPlacements(e){if(getBasePlacement(e)===auto)return[];var t=getOppositePlacement(e);return[getOppositeVariationPlacement(e),t,getOppositeVariationPlacement(t)]}function flip(e){var t=e.state,A=e.options,i=e.name;if(!t.modifiersData[i]._skip){for(var n=A.mainAxis,a=void 0===n||n,r=A.altAxis,s=void 0===r||r,o=A.fallbackPlacements,l=A.padding,c=A.boundary,d=A.rootBoundary,h=A.altBoundary,u=A.flipVariations,g=void 0===u||u,p=A.allowedAutoPlacements,m=t.options.placement,w=getBasePlacement(m),f=o||(w!==m&&g?getExpandedFallbackPlacements(m):[getOppositePlacement(m)]),E=[m].concat(f).reduce((function(e,A){return e.concat(getBasePlacement(A)===auto?computeAutoPlacement(t,{placement:A,boundary:c,rootBoundary:d,padding:l,flipVariations:g,allowedAutoPlacements:p}):A)}),[]),B=t.rects.reference,b=t.rects.popper,v=new Map,C=!0,y=E[0],F=0;F=0,k=I?"width":"height",U=detectOverflow(t,{placement:x,boundary:c,rootBoundary:d,altBoundary:h,padding:l}),Q=I?T?right:left:T?bottom:top;B[k]>b[k]&&(Q=getOppositePlacement(Q));var O=getOppositePlacement(Q),L=[];if(a&&L.push(U[S]<=0),s&&L.push(U[Q]<=0,U[O]<=0),L.every((function(e){return e}))){y=x,C=!1;break}v.set(x,L)}if(C)for(var M=function(e){var t=E.find((function(t){var A=v.get(t);if(A)return A.slice(0,e).every((function(e){return e}))}));if(t)return y=t,"break"},N=g?3:1;N>0&&"break"!==M(N);N--);t.placement!==y&&(t.modifiersData[i]._skip=!0,t.placement=y,t.reset=!0)}}var flip$1={name:"flip",enabled:!0,phase:"main",fn:flip,requiresIfExists:["offset"],data:{_skip:!1}};function getSideOffsets(e,t,A){return void 0===A&&(A={x:0,y:0}),{top:e.top-t.height-A.y,right:e.right-t.width+A.x,bottom:e.bottom-t.height+A.y,left:e.left-t.width-A.x}}function isAnySideFullyClipped(e){return[top,right,bottom,left].some((function(t){return e[t]>=0}))}function hide(e){var t=e.state,A=e.name,i=t.rects.reference,n=t.rects.popper,a=t.modifiersData.preventOverflow,r=detectOverflow(t,{elementContext:"reference"}),s=detectOverflow(t,{altBoundary:!0}),o=getSideOffsets(r,i),l=getSideOffsets(s,n,a),c=isAnySideFullyClipped(o),d=isAnySideFullyClipped(l);t.modifiersData[A]={referenceClippingOffsets:o,popperEscapeOffsets:l,isReferenceHidden:c,hasPopperEscaped:d},t.attributes.popper=Object.assign({},t.attributes.popper,{"data-popper-reference-hidden":c,"data-popper-escaped":d})}var hide$1={name:"hide",enabled:!0,phase:"main",requiresIfExists:["preventOverflow"],fn:hide};function distanceAndSkiddingToXY(e,t,A){var i=getBasePlacement(e),n=[left,top].indexOf(i)>=0?-1:1,a="function"==typeof A?A(Object.assign({},t,{placement:e})):A,r=a[0],s=a[1];return r=r||0,s=(s||0)*n,[left,right].indexOf(i)>=0?{x:s,y:r}:{x:r,y:s}}function offset(e){var t=e.state,A=e.options,i=e.name,n=A.offset,a=void 0===n?[0,0]:n,r=placements.reduce((function(e,A){return e[A]=distanceAndSkiddingToXY(A,t.rects,a),e}),{}),s=r[t.placement],o=s.x,l=s.y;null!=t.modifiersData.popperOffsets&&(t.modifiersData.popperOffsets.x+=o,t.modifiersData.popperOffsets.y+=l),t.modifiersData[i]=r}var offset$1={name:"offset",enabled:!0,phase:"main",requires:["popperOffsets"],fn:offset};function popperOffsets(e){var t=e.state,A=e.name;t.modifiersData[A]=computeOffsets({reference:t.rects.reference,element:t.rects.popper,strategy:"absolute",placement:t.placement})}var popperOffsets$1={name:"popperOffsets",enabled:!0,phase:"read",fn:popperOffsets,data:{}};function getAltAxis(e){return"x"===e?"y":"x"}function preventOverflow(e){var t=e.state,A=e.options,i=e.name,n=A.mainAxis,a=void 0===n||n,r=A.altAxis,s=void 0!==r&&r,o=A.boundary,l=A.rootBoundary,c=A.altBoundary,d=A.padding,h=A.tether,u=void 0===h||h,g=A.tetherOffset,p=void 0===g?0:g,m=detectOverflow(t,{boundary:o,rootBoundary:l,padding:d,altBoundary:c}),w=getBasePlacement(t.placement),f=getVariation(t.placement),E=!f,B=getMainAxisFromPlacement(w),b=getAltAxis(B),v=t.modifiersData.popperOffsets,C=t.rects.reference,y=t.rects.popper,F="function"==typeof p?p(Object.assign({},t.rects,{placement:t.placement})):p,x="number"==typeof F?{mainAxis:F,altAxis:F}:Object.assign({mainAxis:0,altAxis:0},F),S=t.modifiersData.offset?t.modifiersData.offset[t.placement]:null,T={x:0,y:0};if(v){if(a){var I,k="y"===B?top:left,U="y"===B?bottom:right,Q="y"===B?"height":"width",O=v[B],L=O+m[k],M=O-m[U],N=u?-y[Q]/2:0,D=f===start?C[Q]:y[Q],R=f===start?-y[Q]:-C[Q],H=t.elements.arrow,P=u&&H?getLayoutRect(H):{width:0,height:0},V=t.modifiersData["arrow#persistent"]?t.modifiersData["arrow#persistent"].padding:getFreshSideObject(),K=V[k],G=V[U],W=within(0,C[Q],P[Q]),z=E?C[Q]/2-N-W-K-x.mainAxis:D-W-K-x.mainAxis,X=E?-C[Q]/2+N+W+G+x.mainAxis:R+W+G+x.mainAxis,Y=t.elements.arrow&&getOffsetParent(t.elements.arrow),j=Y?"y"===B?Y.clientTop||0:Y.clientLeft||0:0,_=null!=(I=null==S?void 0:S[B])?I:0,J=O+X-_,Z=within(u?min(L,O+z-_-j):L,O,u?max(M,J):M);v[B]=Z,T[B]=Z-O}if(s){var q,$="x"===B?top:left,ee="x"===B?bottom:right,te=v[b],Ae="y"===b?"height":"width",ie=te+m[$],ne=te-m[ee],ae=-1!==[top,left].indexOf(w),re=null!=(q=null==S?void 0:S[b])?q:0,se=ae?ie:te-C[Ae]-y[Ae]-re+x.altAxis,oe=ae?te+C[Ae]+y[Ae]-re-x.altAxis:ne,le=u&&ae?withinMaxClamp(se,te,oe):within(u?se:ie,te,u?oe:ne);v[b]=le,T[b]=le-te}t.modifiersData[i]=T}}var preventOverflow$1={name:"preventOverflow",enabled:!0,phase:"main",fn:preventOverflow,requiresIfExists:["offset"]};function getHTMLElementScroll(e){return{scrollLeft:e.scrollLeft,scrollTop:e.scrollTop}}function getNodeScroll(e){return e!==getWindow(e)&&isHTMLElement(e)?getHTMLElementScroll(e):getWindowScroll(e)}function isElementScaled(e){var t=e.getBoundingClientRect(),A=round(t.width)/e.offsetWidth||1,i=round(t.height)/e.offsetHeight||1;return 1!==A||1!==i}function getCompositeRect(e,t,A){void 0===A&&(A=!1);var i=isHTMLElement(t),n=isHTMLElement(t)&&isElementScaled(t),a=getDocumentElement(t),r=getBoundingClientRect(e,n,A),s={scrollLeft:0,scrollTop:0},o={x:0,y:0};return(i||!i&&!A)&&(("body"!==getNodeName(t)||isScrollParent(a))&&(s=getNodeScroll(t)),isHTMLElement(t)?((o=getBoundingClientRect(t,!0)).x+=t.clientLeft,o.y+=t.clientTop):a&&(o.x=getWindowScrollBarX(a))),{x:r.left+s.scrollLeft-o.x,y:r.top+s.scrollTop-o.y,width:r.width,height:r.height}}function order(e){var t=new Map,A=new Set,i=[];function n(e){A.add(e.name),[].concat(e.requires||[],e.requiresIfExists||[]).forEach((function(e){if(!A.has(e)){var i=t.get(e);i&&n(i)}})),i.push(e)}return e.forEach((function(e){t.set(e.name,e)})),e.forEach((function(e){A.has(e.name)||n(e)})),i}function orderModifiers(e){var t=order(e);return modifierPhases.reduce((function(e,A){return e.concat(t.filter((function(e){return e.phase===A})))}),[])}function debounce(e){var t;return function(){return t||(t=new Promise((function(A){Promise.resolve().then((function(){t=void 0,A(e())}))}))),t}}function mergeByName(e){var t=e.reduce((function(e,t){var A=e[t.name];return e[t.name]=A?Object.assign({},A,t,{options:Object.assign({},A.options,t.options),data:Object.assign({},A.data,t.data)}):t,e}),{});return Object.keys(t).map((function(e){return t[e]}))}var DEFAULT_OPTIONS={placement:"bottom",modifiers:[],strategy:"absolute"};function areValidElements(){for(var e=arguments.length,t=new Array(e),A=0;A(this.setSelectedItem(this.selectedItem-1,!0),!1))),A.register([],"ArrowDown",(()=>(this.setSelectedItem(this.selectedItem+1,!0),!1))),A.register([],"Enter",(e=>(this.useSelectedItem(e),!1))),A.register([],"Tab",(e=>(this.chooseSuggestion(e),!1)))}chooseSuggestion(e){if(!this.items||!this.items.length)return;const t=this.items[this.selectedItem];t&&this.owner.onChooseSuggestion(t,e)}onSuggestionClick(e,t){if(e.preventDefault(),!this.suggestions||!this.suggestions.length)return;const A=this.suggestions.indexOf(t);this.setSelectedItem(A,!1),this.useSelectedItem(e)}onSuggestionMouseover(e,t){if(!this.suggestions||!this.suggestions.length)return;const A=this.suggestions.indexOf(t);this.setSelectedItem(A,!1)}empty(){this.containerEl.empty()}setSuggestions(e){this.containerEl.empty();const t=[];e.forEach((e=>{const A=this.containerEl.createDiv("suggestion-item");this.owner.renderSuggestion(e,A),t.push(A)})),this.items=e,this.suggestions=t,this.setSelectedItem(0,!1)}useSelectedItem(e){if(!this.items||!this.items.length)return;const t=this.items[this.selectedItem];t&&this.owner.selectSuggestion(t,e)}wrap(e,t){return(e%t+t)%t}setSelectedItem(e,t){const A=this.wrap(e,this.suggestions.length),i=this.suggestions[this.selectedItem],n=this.suggestions[A];i&&i.removeClass("is-selected"),n&&n.addClass("is-selected"),this.selectedItem=A,t&&n.scrollIntoView(!1)}}class SuggestionModal extends obsidian_module.FuzzySuggestModal{constructor(e,t,A){super(e),this.items=[],this.scope=new obsidian_module.Scope(this.app.scope),this.emptyStateText="No match found",this.limit=100,this.inputEl=t,this.items=A,this.suggestEl=createDiv("suggestion-container"),this.contentEl=this.suggestEl.createDiv("suggestion"),this.suggester=new Suggester(this,this.contentEl,this.scope),this.scope.register([],"Escape",this.onEscape.bind(this)),this.inputEl.addEventListener("input",this.onInputChanged.bind(this)),this.inputEl.addEventListener("focus",this.onFocus.bind(this)),this.inputEl.addEventListener("blur",this.close.bind(this)),this.suggestEl.on("mousedown",".suggestion-container",(e=>{e.preventDefault()}))}empty(){this.suggester.empty()}onInputChanged(){if(this.shouldNotOpen)return;const e=this.modifyInput(this.inputEl.value),t=this.getSuggestions(e);t.length>0?this.suggester.setSuggestions(t.slice(0,this.limit)):this.onNoSuggestion(),this.open()}onFocus(){this.shouldNotOpen=!1,this.onInputChanged()}modifyInput(e){return e}onNoSuggestion(){this.empty(),this.renderSuggestion(null,this.contentEl.createDiv("suggestion-item"))}open(){this.app.keymap.pushScope(this.scope),this.inputEl.ownerDocument.body.appendChild(this.suggestEl),this.popper=createPopper(this.inputEl,this.suggestEl,{placement:"bottom-start",modifiers:[{name:"offset",options:{offset:[0,10]}},{name:"flip",options:{fallbackPlacements:["top"]}}]})}onEscape(){this.close(),this.shouldNotOpen=!0}close(){this.app.keymap.popScope(this.scope),this.suggester.setSuggestions([]),this.popper&&this.popper.destroy(),this.suggestEl.detach()}createPrompt(e){this.promptEl||(this.promptEl=this.suggestEl.createDiv("prompt-instructions"));const t=this.promptEl.createDiv("prompt-instruction");for(const A of e)t.appendChild(A)}}class FileSuggestionModal extends SuggestionModal{constructor(e,t,A){super(e,t.inputEl,A),this.limit=20,this.files=[...A],this.text=t,this.inputEl.addEventListener("input",(()=>this.getFile()))}getFile(){const e=this.inputEl.value,t=this.app.vault.getAbstractFileByPath(e);t!==this.file&&t instanceof obsidian_module.TFile&&(this.file=t,this.onInputChanged())}getSelectedItem(){return this.file}getItemText(e){return e.path}onChooseItem(e){this.file=e,this.text.setValue(e.path),this.text.onChanged()}selectSuggestion({item:e}){this.file=e,this.text.setValue(e.path),this.onClose(),this.text.onChanged(),this.close()}renderSuggestion(e,t){const{item:A,match:i}=e||{},n=t.createDiv({cls:"suggestion-content"});if(!A)return n.setText(this.emptyStateText),void n.parentElement.addClass("is-selected");const a=A.path.length-A.name.length,r=i.matches.map((e=>createSpan("suggestion-highlight")));for(let e=a;et[0]===e));if(t){const a=r[i.matches.indexOf(t)];n.appendChild(a),a.appendText(A.path.substring(t[0],t[1])),e+=t[1]-t[0]-1}else n.appendText(A.path[e])}t.createDiv({cls:"suggestion-note",text:A.path})}getItems(){return this.files}}const insertImageToView=async(e,t,A,i)=>{e.clear(),e.style.strokeColor="transparent",e.style.backgroundColor="transparent";const n=e.getExcalidrawAPI();e.canvas.theme=n.getAppState().theme;const a=await e.addImage(t.x,t.y,A,i);return await e.addElementsToView(!1,!0,!0),a},insertEmbeddableToView=async(e,t,A,i)=>{if(e.clear(),e.style.strokeColor="transparent",e.style.backgroundColor="transparent",A&&IMAGE_TYPES.contains(A.extension)||e.isExcalidrawFile(A))return await insertImageToView(e,t,A);{const n=e.addEmbeddable(t.x,t.y,500,500,i,A);return await e.addElementsToView(!1,!0,!0),n}},getEA=e=>{try{return window.ExcalidrawAutomate.getAPI(e)}catch(e){return console.log({message:"Excalidraw not available",fn:getEA}),null}};class InsertPDFModal extends obsidian_module.Modal{constructor(e,t){super(app),this.plugin=e,this.view=t,this.borderBox=!0,this.gapSize=20,this.numColumns=1,this.lockAfterImport=!0,this.pagesToImport=[],this.pageDimensions={width:0,height:0},this.importScale=.3,this.dirty=!1,this.setImageSizeMessage=()=>this.imageSizeMessage.innerText=`${Math.round(this.pageDimensions.width*this.importScale)} x ${Math.round(this.pageDimensions.height*this.importScale)}`}open(e){e&&"pdf"===e.extension.toLowerCase()&&(this.pdfFile=e),super.open()}onOpen(){this.containerEl.classList.add("excalidraw-release"),this.titleEl.setText("Import PDF"),this.createForm()}async onClose(){this.dirty&&(this.plugin.settings.pdfImportScale=this.importScale,this.plugin.settings.pdfBorderBox=this.borderBox,this.plugin.settings.pdfGapSize=this.gapSize,this.plugin.settings.pdfNumColumns=this.numColumns,this.plugin.settings.pdfLockAfterImport=this.lockAfterImport,this.plugin.saveSettings()),this.pdfDoc&&(this.pdfDoc.destroy(),this.pdfDoc=null)}async getPageDimensions(e){try{const t=this.plugin.settings.pdfScale,A=createEl("canvas"),i=(await e.getPage(1)).getViewport({scale:t});this.pageDimensions.height=i.height,this.pageDimensions.width=i.width,A.width=0,A.height=0,this.setImageSizeMessage()}catch(e){console.log(e)}}createPageListFromString(e){const t=e=>e.replace(/\D/g,"");return this.pagesToImport=[],e.split(",").forEach((e=>{const A=e.split("-");if(1===A.length){const e=parseInt(t(A[0]));!isNaN(e)&&this.pagesToImport.push(e)}else if(2===A.length){const e=parseInt(t(A[0])),i=parseInt(t(A[1]));if(isNaN(e)||isNaN(i))return;for(let t=e;t<=i;t++)this.pagesToImport.push(t)}})),this.pagesToImport}async createForm(){await this.plugin.loadSettings(),this.borderBox=this.plugin.settings.pdfBorderBox,this.gapSize=this.plugin.settings.pdfGapSize,this.numColumns=this.plugin.settings.pdfNumColumns,this.lockAfterImport=this.plugin.settings.pdfLockAfterImport,this.importScale=this.plugin.settings.pdfImportScale;const e=this.contentEl;let t,A,i,n;const a=()=>this.pdfDoc?0===this.pagesToImport.length?(i.buttonEl.style.display="none",void(n.innerText="Please select pages to import")):Math.max(...this.pagesToImport)<=this.pdfDoc.numPages?(i.buttonEl.style.display="block",void(n.innerText="")):(i.buttonEl.style.display="none",void(n.innerText=`The selected document has ${this.pdfDoc.numPages} pages. Please select pages between 1 and ${this.pdfDoc.numPages}`)):(n.innerText="Please select a PDF file",void(i.buttonEl.style.display="none")),r=()=>{0!==A?t.innerHTML=`There are ${A} pages in the selected document.`:t.innerText="Please select a PDF file"},s=async e=>{this.pdfDoc&&await this.pdfDoc.destroy(),this.pdfDoc=null,e&&(this.pdfDoc=await getPDFDoc(e),this.pdfFile=e,this.pdfDoc?(A=this.pdfDoc.numPages,a(),r(),this.getPageDimensions(this.pdfDoc)):i.setDisabled(!0))},o=new obsidian_module.TextComponent(e);o.inputEl.style.width="100%";const l=new FileSuggestionModal(this.app,o,app.vault.getFiles().filter((e=>"pdf"===e.extension.toLowerCase())));let c,d,h,u;o.onChange((async()=>{const e=l.getSelectedItem();await s(e)})),t=e.createEl("p",{text:""}),r(),new obsidian_module.Setting(e).setName("Pages to import").addText((e=>{d=e,e.setPlaceholder("e.g.: 1,3-5,7,9-10").onChange((e=>{const t=this.createPageListFromString(e);t.length>15?c.innerHTML=`You are importing ${t.length} pages. ⚠️ This may take a while. ⚠️`:c.innerHTML=`You are importing ${t.length} pages.`,a()})),e.inputEl.style.width="100%"})),c=e.createEl("p",{text:""}),new obsidian_module.Setting(e).setName("Add border box").addToggle((e=>e.setValue(this.borderBox).onChange((e=>{this.borderBox=e,this.dirty=!0})))),new obsidian_module.Setting(e).setName("Lock pages on canvas after import").addToggle((e=>e.setValue(this.lockAfterImport).onChange((e=>{this.lockAfterImport=e,this.dirty=!0})))),new obsidian_module.Setting(e).setName("Number of columns").addSlider((e=>e.setLimits(1,100,1).setValue(this.numColumns).onChange((e=>{this.numColumns=e,h.innerText=` ${e.toString()}`,this.dirty=!0})))).settingEl.createDiv("",(e=>{h=e,e.style.minWidth="2.3em",e.style.textAlign="right",e.innerText=` ${this.numColumns.toString()}`})),new obsidian_module.Setting(e).setName("Size of gap between pages").addSlider((e=>e.setLimits(10,200,10).setValue(this.gapSize).onChange((e=>{this.gapSize=e,u.innerText=` ${e.toString()}`,this.dirty=!0})))).settingEl.createDiv("",(e=>{u=e,e.style.minWidth="2.3em",e.style.textAlign="right",e.innerText=` ${this.gapSize.toString()}`}));const g=new obsidian_module.Setting(e).setName("Imported page size").setDesc(`${this.pageDimensions.width*this.importScale} x ${this.pageDimensions.height*this.importScale}`).addSlider((e=>e.setLimits(.1,1.5,.1).setValue(this.importScale).onChange((e=>{this.importScale=e,this.dirty=!0,this.setImageSizeMessage()}))));this.imageSizeMessage=g.descEl;const p=new obsidian_module.Setting(e).setDesc("Select a document first").addButton((e=>{e.setButtonText("Import PDF").setCta().onClick((async()=>{const e=getEA(this.view);let t=0,A=0;const i=Math.round(this.pageDimensions.width*this.importScale),a=Math.round(this.pageDimensions.height*this.importScale);for(let r=0;re.id)),o=e.getViewElements().filter((e=>s.includes(e.id)));r.selectElements(o),r.zoomToFit(o),this.close()})),i=e,i.buttonEl.style.display="none"}));n=p.descEl,n.addClass("mod-warning"),this.pdfFile?(o.setValue(this.pdfFile.path),await s(this.pdfFile),l.close(),d.inputEl.focus()):o.inputEl.focus(),a()}}class UniversalInsertFileModal extends obsidian_module.Modal{constructor(e,t){super(app),this.plugin=e,this.view=t,this.center={x:0,y:0};const A=t.excalidrawAPI.getAppState(),i=t.containerEl.getBoundingClientRect(),n=window.innerWidth||document.documentElement.clientWidth,a=window.innerHeight||document.documentElement.clientHeight,r=sceneCoordsToViewportCoords({sceneX:t.currentPosition.x,sceneY:t.currentPosition.y},A);if(r.x>=i.left+150&&r.y<=i.right-150&&r.y>=i.top+150&&r.y<=i.bottom-150){const e=t.currentPosition.x-250,A=t.currentPosition.y-250;this.center={x:e,y:A}}else{const e=i.left+i.width/2,t=i.top+i.height/2,r=Math.max(0,Math.min(n,e)),s=Math.max(0,Math.min(a,t));this.center=viewportCoordsToSceneCoords({clientX:r,clientY:s},A),this.center={x:this.center.x-250,y:this.center.y-250}}}onOpen(){this.containerEl.classList.add("excalidraw-release"),this.titleEl.setText("Insert File From Vault"),this.createForm()}async createForm(){const e=this.contentEl;let t,A,i,n,a,r,s,o=!1;const l=async()=>{const e=this.plugin.ea,o=s&&"md"===s.extension&&!e.isExcalidrawFile(s),l=s&&(IMAGE_TYPES.contains(s.extension)||e.isExcalidrawFile(s)),c=s&&!l,d=s&&"pdf"===s.extension,h=s&&e.isExcalidrawFile(s);if(o){for(A.settingEl.style.display="",t.selectEl.style.display="block";t.selectEl.options.length>0;)t.selectEl.remove(0);t.addOption("",""),(await app.metadataCache.blockCache.getForFile({isCancelled:()=>!1},s)).blocks.filter((e=>{var t;return e.display&&"heading"===(null===(t=e.node)||void 0===t?void 0:t.type)})).forEach((e=>{t.addOption(`#${e.display.replaceAll(REG_BLOCK_REF_CLEAN,"").trim()}`,e.display)}))}else A.settingEl.style.display="none",t.selectEl.style.display="none";r.settingEl.style.display=h?"":"none",l||"md"===(null==s?void 0:s.extension)?n.buttonEl.style.display="block":n.buttonEl.style.display="none",i.buttonEl.style.display=c?"block":"none",a.buttonEl.style.display=d?"block":"none"},c=new obsidian_module.TextComponent(e);c.inputEl.style.width="100%";const d=new FileSuggestionModal(this.app,c,app.vault.getFiles().filter((e=>e!==this.view.file)));c.onChange((()=>{s=d.getSelectedItem(),l()})),A=new obsidian_module.Setting(e).setName("Select section heading").addDropdown((e=>{t=e,t.selectEl.style.width="100%"})),r=new obsidian_module.Setting(e).setName("Anchor to 100% of original size").setDesc("This is a pro feature, use it only if you understand how it works. If enabled even if you change the size of the imported image in Excalidraw, the next time you open the drawing this image will pop back to 100% size. This is useful when embedding an atomic Excalidraw idea into another note and preserving relative sizing of text and icons.").addToggle((e=>{e.setValue(o).onChange((e=>{o=e}))})),new obsidian_module.Setting(e).addButton((e=>{e.setButtonText("as iFrame").onClick((async()=>{const e=app.metadataCache.fileToLinktext(s,this.view.file.path,"md"===s.extension),A=getEA(this.view);A.selectElementsInView([await insertEmbeddableToView(A,this.center,void 0,`[[${e}${t.selectEl.value}]]`)]),this.close()})),i=e})).addButton((e=>{e.setButtonText("as Pdf").onClick((()=>{new InsertPDFModal(this.plugin,this.view).open(s),this.close()})),a=e})).addButton((e=>{e.setButtonText("as Image").onClick((async()=>{const e=getEA(this.view),A=s&&"md"===s.extension&&!e.isExcalidrawFile(s);e.selectElementsInView([await insertImageToView(e,this.center,A&&t.selectEl.value&&""!==t.selectEl.value?`${s.path}${t.selectEl.value}`:s,e.isExcalidrawFile(s)?!o:void 0)]),this.close()})),n=e})),this.view.ownerWindow.addEventListener("keydown",this.onKeyDown=e=>{const t=e=>"none"!==e.buttonEl.style.display;switch(e.key){case"Escape":return void this.close();case"Enter":return!t(i)||t(n)||t(a)?!t(n)||t(i)||t(a)?!t(a)||t(i)||t(n)?void 0:void a.buttonEl.click():void n.buttonEl.click():void i.buttonEl.click();case"i":return void(t(n)&&n.buttonEl.click());case"p":return void(t(a)&&a.buttonEl.click());case"f":return void(t(i)&&i.buttonEl.click())}}),c.inputEl.focus(),l()}onClose(){this.view.ownerWindow.removeEventListener("keydown",this.onKeyDown)}}const setPen=(e,t)=>{const A=t.getAppState();t.updateScene({appState:Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({currentStrokeOptions:e.penOptions},e.strokeWidth&&0!==e.strokeWidth?{currentItemStrokeWidth:e.strokeWidth}:null),e.backgroundColor?{currentItemBackgroundColor:e.backgroundColor}:null),e.strokeColor?{currentItemStrokeColor:e.strokeColor}:null),""===e.fillStyle?null:{currentItemFillStyle:e.fillStyle}),e.roughness?null:{currentItemRoughness:e.roughness}),e.freedrawOnly&&!A.resetCustomPen?{resetCustomPen:{currentItemStrokeWidth:A.currentItemStrokeWidth,currentItemBackgroundColor:A.currentItemBackgroundColor,currentItemStrokeColor:A.currentItemStrokeColor,currentItemFillStyle:A.currentItemFillStyle,currentItemRoughness:A.currentItemRoughness}}:null)})},resetStrokeOptions=(e,t,A)=>{t.updateScene({appState:Object.assign(Object.assign(Object.assign({},e?{currentItemStrokeWidth:e.currentItemStrokeWidth,currentItemBackgroundColor:e.currentItemBackgroundColor,currentItemStrokeColor:e.currentItemStrokeColor,currentItemFillStyle:e.currentItemFillStyle,currentItemRoughness:e.currentItemRoughness}:null),{resetCustomPen:null}),A?{currentStrokeOptions:null}:null)})};class ObsidianMenu{constructor(e,t,A){this.plugin=e,this.toolsRef=t,this.view=A,this.renderCustomPens=(e,t)=>{var A;return null===(A=t.customPens)||void 0===A?void 0:A.map(((A,i)=>{const n=this.plugin.settings.customPens[i];return t.resetCustomPen&&"freedraw"!==t.activeTool.type&&t.currentStrokeOptions===n.penOptions&&setTimeout((()=>resetStrokeOptions(t.resetCustomPen,this.view.excalidrawAPI,!1))),!t.resetCustomPen&&"freedraw"===t.activeTool.type&&t.currentStrokeOptions===n.penOptions&&n.freedrawOnly&&setTimeout((()=>setPen(this.activePen,this.view.excalidrawAPI))),this.activePen&&t.resetCustomPen&&"freedraw"===t.activeTool.type&&t.currentStrokeOptions===n.penOptions&&n.freedrawOnly&&(this.activePen.strokeWidth=t.currentItemStrokeWidth,this.activePen.backgroundColor=t.currentItemBackgroundColor,this.activePen.strokeColor=t.currentItemStrokeColor,this.activePen.fillStyle=t.currentItemFillStyle,this.activePen.roughness=t.currentItemRoughness),React__namespace.createElement("label",{key:i,className:clsx("ToolIcon","ToolIcon_size_medium",{"is-mobile":e}),onClick:()=>{const e=Date.now();if(e-this.clickTimestamp[i]<500){const e=new PenSettingsModal(this.plugin,this.view,i);return void(async()=>{await this.plugin.loadSettings(),e.open()})()}this.clickTimestamp[i]=e;const t=this.view.excalidrawAPI,A=t.getAppState();A.currentStrokeOptions!==n.penOptions||"freedraw"!==A.activeTool.type?(this.activePen=Object.assign({},n),setPen(n,t),t.setActiveTool({type:"freedraw"})):resetStrokeOptions(A.resetCustomPen,t,!0)}},React__namespace.createElement("div",{className:"ToolIcon__icon","aria-label":n.type,style:Object.assign({},"freedraw"===t.activeTool.type&&t.currentStrokeOptions===n.penOptions?{background:"var(--color-primary)"}:{})},penIcon(n)))}))},this.longpressTimeout={},this.renderPinnedScriptButtons=(e,t)=>{var A;let i=0;return null===(A=null==t?void 0:t.pinnedScripts)||void 0===A?void 0:A.map(((t,A)=>{var n;const a=this.plugin.scriptEngine.scriptIconMap[t],r=null!==(n=null==a?void 0:a.name)&&void 0!==n?n:"",s=(null==a?void 0:a.svgString)?stringToSVG(a.svgString):ICONS.cog;return this.longpressTimeout[A]||(this.longpressTimeout[A]=0),React__namespace.createElement("label",{key:A,className:clsx("ToolIcon","ToolIcon_size_medium",{"is-mobile":e}),onPointerUp:()=>{this.longpressTimeout[A]&&(window.clearTimeout(this.longpressTimeout[A]),this.longpressTimeout[A]=0,(async()=>{const e=app.vault.getAbstractFileByPath(t);e&&e instanceof obsidian_module.TFile&&this.plugin.scriptEngine.executeScript(this.view,await app.vault.read(e),this.plugin.scriptEngine.getScriptName(e),e)})())},onPointerDown:()=>{const e=Date.now();this.longpressTimeout[A]>0&&(window.clearTimeout(this.longpressTimeout[A]),this.longpressTimeout[A]=0),e-i>=500&&(this.longpressTimeout[A]=window.setTimeout((()=>{this.longpressTimeout[A]=0,(async()=>{var e;await this.plugin.loadSettings();const A=this.plugin.settings.pinnedScripts.indexOf(t);A>-1&&(this.plugin.settings.pinnedScripts.splice(A,1),null===(e=this.view.excalidrawAPI)||void 0===e||e.setToast({message:`Pin removed: ${r}`,duration:3e3,closable:!0})),await this.plugin.saveSettings(),app.workspace.getLeavesOfType("excalidraw").forEach((e=>{e.view instanceof ExcalidrawView&&e.view.updatePinnedScripts()}))})()}),1500)),i=e}},React__namespace.createElement("div",{className:"ToolIcon__icon","aria-label":r},s))}))},this.renderButton=(e,t)=>React__namespace.createElement(React__namespace.Fragment,null,React__namespace.createElement("label",{className:clsx("ToolIcon","ToolIcon_size_medium",{"is-mobile":e}),onClick:()=>{this.toolsRef.current.setTheme(t.theme),this.toolsRef.current.toggleVisibility(t.zenModeEnabled||e)}},React__namespace.createElement("div",{className:"ToolIcon__icon","aria-label":t$d("OBSIDIAN_TOOLS_PANEL")},ICONS.obsidian)),React__namespace.createElement("label",{className:clsx("ToolIcon","ToolIcon_size_medium",{"is-mobile":e}),onClick:()=>{new UniversalInsertFileModal(this.plugin,this.view).open()}},React__namespace.createElement("div",{className:"ToolIcon__icon","aria-label":t$d("UNIVERSAL_ADD_FILE")},ICONS["add-file"])),this.renderCustomPens(e,t),this.renderPinnedScriptButtons(e,t)),this.clickTimestamp=Array.from({length:Object.keys(PENS).length},(()=>0))}}class ActionButton extends React__namespace.Component{constructor(e){super(e),this.toastMessageTimeout=0,this.longpressTimeout=0,this.state={visible:!0}}render(){return React__namespace.createElement("button",{style:{},className:"ToolIcon_type_button ToolIcon_size_small ToolIcon_type_button--show ToolIcon",title:this.props.title,onClick:e=>{this.toastMessageTimeout&&(window.clearTimeout(this.toastMessageTimeout),this.toastMessageTimeout=0,this.props.action(e)),this.longpressTimeout&&(window.clearTimeout(this.longpressTimeout),this.longpressTimeout=0)},onPointerDown:e=>{this.toastMessageTimeout=window.setTimeout((()=>{var e;null===(e=this.props.view.excalidrawAPI)||void 0===e||e.setToast({message:this.props.title,duration:3e3,closable:!0}),this.toastMessageTimeout=0}),400),this.longpressTimeout=window.setTimeout((()=>{var t;this.props.longpress?this.props.longpress(e):null===(t=this.props.view.excalidrawAPI)||void 0===t||t.setToast({message:"Cannot pin this action",duration:3e3,closable:!0}),this.longpressTimeout=0}),1500)}},React__namespace.createElement("div",{className:"ToolIcon__icon","aria-hidden":"true"},this.props.icon))}}const FIRST_RUN='\nThe Excalidraw Obsidian plugin is much more than "just" a drawing tool. To help you get started here\'s a showcase of the key Excalidraw plugin features.\n\nIf you\'d like to learn more, please subscribe to my YouTube channel: [Visual PKM](https://www.youtube.com/channel/UCC0gns4a9fhVkGkngvSumAQ) where I regularly share videos about Obsidian-Excalidraw and about tools and techniques for Visual Personal Knowledge Management.\n\nThank you & Enjoy!\n\n
\n\n
\n',RELEASE_NOTES={Intro:'After each update you\'ll be prompted with the release notes. You can disable this in plugin settings.\n\nI develop this plugin as a hobby, spending my free time doing this. If you find it valuable, then please say THANK YOU or...\n\n
\n',"1.9.10":'\n## New\n- @mazurov added a new script: [Ellipse Selected Elements](https://github.com/zsviczian/obsidian-excalidraw-plugin/blob/master/ea-scripts/Ellipse%20Selected%20Elements.md)\n\n## Fixed\n- **Image Saving Error**: Previously, inserting an image from Firebase Storage or other URLs could result in an error that prevented the entire drawing from being saved. I have now improved the error handling and image fetching from the web, ensuring smooth image insertion and saving. \n- **Text Search Bug**: There was an issue where text search failed when frames had default names like "Frame 1," "Frame 2," etc. This has been resolved, and now the text search works correctly in such cases. ([#1239](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1239)) \n- **Image Positioning Fix**: An annoying bug caused the image to jump after inserting it using the "Insert Image" command palette action. I\'ve fixed this issue, and now the image behaves as expected when positioning it for the first time.\n',"1.9.9":`\n## ⚠️⚠️ IMPORTANT: PLEASE READ ⚠️⚠️\n\nI updated embedded frames for compatibility with excalidraw.com. To ensure everything works smoothly:\n\n🔄 Update Excalidraw on all your devices.\n\nThis will avoid any issues with converted files and let you enjoy the new features seamlessly.\n\nThank you for your understanding. If you have any questions, feel free to reach out.\n\n---\n\n## Fixed:\n- PNG image caching resulting in broken images after Obsidian restarts\n- SVG export now displays embedded iframes with the correct embed link (note this feature only works when you open the SVGs in a browser outside Obsidian).\n\n## Updated / fixed in Excalidraw Automate\n- I updated ${String.fromCharCode(96)}lib/ExcalidrawAutomate.d.ts${String.fromCharCode(96)} and published a new version of obsidian-excalidraw-plugin type library to npmjs.\n- Added new ExcalidrawAutomate functions: ${String.fromCharCode(96)} addEmbeddable()${String.fromCharCode(96)}, ${String.fromCharCode(96)}DEVICE${String.fromCharCode(96)}, ${String.fromCharCode(96)}newFilePrompt()${String.fromCharCode(96)}, and ${String.fromCharCode(96)}getLeaf()${String.fromCharCode(96)}\n- ${String.fromCharCode(96)}addImage${String.fromCharCode(96)} and ${String.fromCharCode(96)}addElementsToView${String.fromCharCode(96)} were extended with 1-1 additional optional parameter. As a result of ${String.fromCharCode(96)}shouldRestoreElements${String.fromCharCode(96)} defaulting to false, all elements in the scene will no longer be updated (iframes will not blink) when you add elements via script.\n- There is a new event hook: ${String.fromCharCode(96)}onPasteHook${String.fromCharCode(96)}. This will be called whenever the user pastes something to the canvas. You can use this callback if you want to do something additional during the onPaste event. In case you want to prevent the Excalidraw default onPaste action you must return false\n\n${String.fromCharCode(96,96,96)}typescript\nasync addImage(\n topX: number,\n topY: number,\n imageFile: TFile | string,\n scale: boolean = true,\n anchor: boolean = true,\n): Promise;\n\nasync addElementsToView(\n repositionToCursor: boolean = false,\n save: boolean = true,\n newElementsOnTop: boolean = false,\n shouldRestoreElements: boolean = false,\n): Promise;\n\n onPasteHook: (data: {\n ea: ExcalidrawAutomate;\n payload: ClipboardData;\n event: ClipboardEvent;\n excalidrawFile: TFile;\n view: ExcalidrawView;\n pointerPosition: { x: number; y: number };\n }) => boolean = null;\n\naddEmbeddable(\n topX: number,\n topY: number,\n width: number,\n height: number,\n url?: string,\n file?: TFile\n): string;\n\nget DEVICE(): DeviceType;\n\nnewFilePrompt(\n newFileNameOrPath: string,\n shouldOpenNewFile: boolean,\n targetPane?: PaneTarget,\n parentFile?: TFile\n): Promise;\n\ngetLeaf(\n origo: WorkspaceLeaf,\n targetPane?: PaneTarget\n): WorkspaceLeaf;\n${String.fromCharCode(96,96,96)}\n`,"1.9.8":'\n## New Features\n- Zoom to heading and block in markdown frames.\n- Added an iframe menu that allows users to change heading/block zoom, center the element, and open it in the browser.\n- Replaced twitframe with platform.twitter for tweets. The "Read more" and "Reply" buttons now work. Embedded tweets will honor theme settings.\n\n## Bug Fixes\n- Fixed an issue where embedded markdown frames disappeared in fullscreen mode. [#1197](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1197)\n- Resolved a problem with the "Embed Markdown as Image" feature where changes to embed properties were not always honored. [#1201](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1201)\n- When inserting any file from the Vault and embedding a Markdown document as an image, the embed now correctly honors the section heading if specified. [#1200](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1200)\n- SVG and PNG autoexport now function properly when closing a popout window. [#1209](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1209)\n- Many other minor fixes\n',"1.9.7":`\n## Fixed:\n\n- Fixed an issue where using the color picker shortcut would cause the UI to disappear in mobile view mode.\n- You can now add YouTube playlists to iframes.\n- Fixed a bug where the "Add any file" dropdown suggester opened in the main Obsidian workspace instead of the popout window when Excalidraw was running. ([#1179](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1191))\n- Made some improvements to the logic of opening in the adjacent pane, although it is still not perfect.\n- Fixed an issue where Obsidian sync would result in the loss of the last approximately 20 seconds of work. Excalidraw's handling of sync is now fixed. ([#1189](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1189))\n\n## New:\n\n- Introducing Image Cache: Excalidraw will now cache rendered images embedded in Markdown documents, which will enhance the markdown rendering experience.\n- Backup Cache: Excalidraw now stores a backup on your device when saving, in case the application is terminated during a save operation. If you are using sync, you can find the latest backup on the device you last used to edit your drawing.\n- Added ${String.fromCharCode(96)}frame=${String.fromCharCode(96)} parameter to image references. ([#1194](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1194)) For more details about this feature, check out this [YouTube video](https://youtu.be/yZQoJg2RCKI).\n- When an SVG image from Draw.io is embedded in Excalidraw, clicking the image will open the file in the [Diagram plugin](https://github.com/zapthedingbat/drawio-obsidian) (if available).\n- Added the [Create DrawIO file](https://github.com/zsviczian/obsidian-excalidraw-plugin/blob/master/ea-scripts/Create%20DrawIO%20file.md) Excalidraw Automate Script to the library, which allows you to create a new draw.io drawing and add it to the current Excalidraw canvas.\n\n## New in ExcalidrawAutomate\n\n${String.fromCharCode(96,96,96)}typescript\nasync getAttachmentFilepath(filename: string): Promise\n${String.fromCharCode(96,96,96)}\n\nThis asynchronous function retrieves the filepath to a new file, taking into account the attachments preference settings in Obsidian. It creates the attachment folder if it doesn't already exist. The function returns the complete path to the file. If the provided filename already exists, the function will append '_[number]' before the extension to generate a unique filename.\n\n${String.fromCharCode(96,96,96)}typescript\ngetElementsInFrame(frameElement: ExcalidrawElement, elements: ExcalidrawElement[]): ExcalidrawElement[];\n${String.fromCharCode(96,96,96)}\n\nThis function returns the elements contained within a frame.\n`,"1.9.6":`\n## Fixed\n- help shortcuts are really hard to see [#1176](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1179)\n- link icons not visible on elements after 1.9.5 release (reported on Discord)\n- PDFs in iFrames will now respect the ${String.fromCharCode(96)}[[document.pdf#page=155]]${String.fromCharCode(96)} format\n- Keyboard shortcuts were not working properly on external drop. Check [updated keyboard map](https://raw.githubusercontent.com/zsviczian/obsidian-excalidraw-plugin/master/images/excalidraw-modifiers.png)\n\nKeyboard map\n`,"1.9.5":`\n
\n\n
\n\n## New\n- IFrame support: insert documents from your Obsidian Vault and insert youtube, Vimeo, and generally any website from the internet\n- Frame support: use frames to group items on your board\n\n## New in ExcalidrawAutomate\n- selectElementsInView now also accepts a list of element IDs\n- new addIFrame function that accepts an Obsidian file or a URL string\n${String.fromCharCode(96,96,96)}typescript\nselectElementsInView(elements: ExcalidrawElement[] | string[]): void;\naddIFrame(topX: number, topY: number, width: number, height: number, url?: string, file?: TFile): string;\n${String.fromCharCode(96,96,96)}\n`,"1.9.3":'\n## New from Excalidraw.com\n- Eyedropper tool. The eyedropper is triggered with "i". If you hold the ALT key while clicking the color it will set the stroke color of the selected element, else the background color.\n- Flipping multiple elements\n- Improved stencil library rendering performance + the stencil library will remember the scroll position from the previous time it was open\n\n## Fixed\n- Replaced command palette and tab export SVG/PNG/Excalidraw actions with "export image" which will take the user to the export image dialog.\n',"1.9.2":`\n
\n\n
\n\n## New\n- Excalidraw.com Color Picker redesign [#6216](https://github.com/excalidraw/excalidraw/pull/6216)\n- Updated palette loader script in the script library\n- New ExcalidrawAutomate API to load Elements and AppState from another Excalidraw file.\n${String.fromCharCode(96,96,96)}typescript\nasync getSceneFromFile(file: TFile): Promise<{elements: ExcalidrawElement[]; appState: AppState;}>\n${String.fromCharCode(96,96,96)}\n`,"1.9.1":'\n## Updates from Excalidraw.com\n- "Unlock all elements" - new action available via the context menu [#5894](https://github.com/excalidraw/excalidraw/pull/5894)\n- Minor improvements to improve the speed [#6560](https://github.com/excalidraw/excalidraw/pull/6560)\n- Retain Seed on Shift Paste [#6509](https://github.com/excalidraw/excalidraw/pull/6509)\n\n## New/Fixed\n- Clicking on the link handle (top right corner) will open the link in the same window\n- CTRL/CMD click on a link will open the link in a new tab and will focus on the new tab\n- Linking to parts of images. In some cases clicking search results, links, or backlinks did not focus on the right element according to the link. Fixed.\n',"1.9.0":`\n
\n\n
\n\n## Fixed\n- Embedded images, markdowns, PDFs will load one by one, not in one go after a long wait\n\n## New\n- Embed PDF\n\n## New in ExcalidrawAutomate\n- onFileCreateHook: if set this hook is called whenever a new drawing is created using Excalidraw command palette menu actions. If the excalidraw file is created using Templater or other means, the trigger will not fire. [#1124](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1124)\n${String.fromCharCode(96,96,96)}typescript\n onFileCreateHook: (data: {\n ea: ExcalidrawAutomate;\n excalidrawFile: TFile; //the file being created\n view: ExcalidrawView;\n }) => Promise;\n ${String.fromCharCode(96,96,96)}\n`,"1.8.26":"\n## Fixed\n- Dynamic styling did not pick up correctly\n - the accent color with the default Obsidian theme\n - the drawing theme color with the out of the box, default new drawing (not using a template)\n- The Obsidian tools panel did not pick up user scripts when installing your very first script. A reload of Obsidian was required.\n","1.8.25":'\n
\n\n
\n\n## New & improved\n- Multi-link support\n- Updated [Scribble Helper](https://github.com/zsviczian/obsidian-excalidraw-plugin/blob/master/ea-scripts/Scribble%20Helper.md) script for better handwritten text support. \n - Add links to text elements\n - Creating wrapped text in transparent sticky notes\n - Add text to arrows and lines\n - Handwriting support on iOS via Scribble\n\n## Fixed\n - The long-standing issue of jumping text\n \n',"1.8.24":`\n## Updates from Excalidraw.com\n- fix: color picker keyboard handling not working\n- fix: center align text when bind to the container via context menu\n- fix: split "Edit selected shape" shortcut\n\n## Fixed\n- BUG: Area embed link of svg inside excalidraw embed entire svg instead of area [#1098](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1098)\n\n## New\n- I updated the [Scribble Helper](https://github.com/zsviczian/obsidian-excalidraw-plugin/blob/master/ea-scripts/Scribble%20Helper.md) script with tons of new features. I am still beta testing the script. I will release a demo video in the next few days.\n\n## New in Excalidraw Automate\n- I added many more configuration options for the scriptEngine utils.inputPrompt function. See [Scribble Helper](https://github.com/zsviczian/obsidian-excalidraw-plugin/blob/master/ea-scripts/Scribble%20Helper.md) for a demonstration of this new feature.\n${String.fromCharCode(96,96,96)}typescript\n public static async inputPrompt(\n view: ExcalidrawView,\n plugin: ExcalidrawPlugin,\n app: App,\n header: string,\n placeholder?: string,\n value?: string,\n buttons?: { caption: string; tooltip?:string; action: Function }[],\n lines?: number,\n displayEditorButtons?: boolean,\n customComponents?: (container: HTMLElement) => void\n )\n${String.fromCharCode(96,96,96)}`,"1.8.23":'\n## Fixes\n- Fixed palm rejection to prevent unwanted spikes when using the freedraw tool. ([#1065](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1065))\n- Fixed issue where images disappeared when zoomed in. ([#6417](https://github.com/excalidraw/excalidraw/pull/6417))\n- Autosave will now save the drawing when you change the theme from dark to light or vice versa. ([#1080](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1080))\n- Added padding to short LaTeX formulas to prevent cropping. ([#1053](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1053))\n\n## New Features\n- Added a new command palette action: Toggle to invert default binding behavior. This new feature allows you to switch between normal and inverted mode. In normal mode, arrows will bind to objects unless you hold the CTRL/CMD key while drawing the arrow or moving objects. In inverted mode, arrows will not bind to objects unless you hold the CTRL/CMD key while drawing the arrow or moving objects.\n- You can now set a template LaTeX formula in the plugin settings (under experimental features) to be used when creating a new LaTeX formula. ([#1090](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1090))\n- Redesigned the Image Export dialog. I hope dropdowns are now more intuitive than the toggles were.\n- Added the ability to export only the selected part of a drawing. See the Export dialog for more information.\n- Added a zigzag fill easter egg. See a demo of this feature [here](https://twitter.com/excalidraw/status/1645428942344445952?s=61&t=nivKLx2vgl6hdv2EbW4mZg).\n- Added a new expert function: recolor embedded Excalidraw and SVG images (not JPG, PNG, BMP, WEBP, GIF). See a demo of this feature here:\n\n
\n\n
\n',"1.8.22":`\n## Fixed\n- Styling of custom pen and script buttons in the side panel was inverted.\n- Minor tweaks to dynamic styling. [see this video to understand dynamic styling](https://youtu.be/fypDth_-8q0)\n\n## New\n- New scripts by @threethan:\n - [Auto Draw for Pen](https://github.com/zsviczian/obsidian-excalidraw-plugin/blob/master/ea-scripts/Auto%20Draw%20for%20Pen.md): Automatically switches between the select and draw tools, based on whether a pen is being used. Supports most pens including Apple Pencil.\n - [Hardware Eraser Support](https://github.com/zsviczian/obsidian-excalidraw-plugin/blob/master/ea-scripts/Hardware%20Eraser%20Support.md): Adds support for pen inversion, a.k.a. the hardware eraser on the back of your pen. Supports Windows based styluses. Does not suppoprt Apple Pencil or S-Pen.\n- Added separate buttons to support copying link, area or group references to objects on the drawing. [#1063](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1063). See [this video](https://youtu.be/yZQoJg2RCKI) for more details on how this works.\n- Hover preview will no longer trigger for image files (.png, .svg, .jpg, .gif, .webp, .bmp, .ico, .excalidraw)\n- Minor updates to the [Slideshow](https://github.com/zsviczian/obsidian-excalidraw-plugin/blob/master/ea-scripts/Slideshow.md) script. You can download the updated script from the Excalidraw script library. The slideshow will now correctly run also when initiated in a popout window. When the drawing is in a popout window, the slideshow will not be full screen, but will only occupy the popout window. If you run the slideshow from the main Obsidian workspace, it will be displayed in full-screen mode.\n- Updated the Icon Library script to now include image keywords under each of the images to allow searching for keywords (CTRL/CMD+F). I've uploaded the new script to [here](https://gist.github.com/zsviczian/33ff695d5b990de1ebe8b82e541c26ad). If you need further information watch this [video](https://youtu.be/_OEljzZ33H8)\n\n## New in ExcalidrawAutomate\n- ${String.fromCharCode(96)}addText${String.fromCharCode(96)} ${String.fromCharCode(96)}formatting${String.fromCharCode(96)} parameter now accepts ${String.fromCharCode(96)}boxStrokeColor${String.fromCharCode(96)} and ${String.fromCharCode(96)}textVerticalAlign${String.fromCharCode(96)} values.\n${String.fromCharCode(96,96,96)}typescript\naddText(\n topX: number,\n topY: number,\n text: string,\n formatting?: {\n wrapAt?: number;\n width?: number;\n height?: number;\n textAlign?: "left" | "center" | "right";\n box?: boolean | "box" | "blob" | "ellipse" | "diamond";\n boxPadding?: number;\n boxStrokeColor?: string;\n textVerticalAlign?: "top" | "middle" | "bottom";\n },\n id?: string,\n ): string;\n${String.fromCharCode(96,96,96)}\n- new ${String.fromCharCode(96)}onFileOpenHook${String.fromCharCode(96)}. If set, this callback is triggered, when an Excalidraw file is opened. You can use this callback in case you want to do something additional when the file is opened. This will run before the file level script defined in the ${String.fromCharCode(96)}excalidraw-onload-script${String.fromCharCode(96)} frontmatter is executed. Excalidraw will await the result of operations here. Handle with care. If you change data such as the frontmatter of the underlying file, I haven't tested how it will behave.\n${String.fromCharCode(96,96,96)}typescript\nonFileOpenHook: (data: {\n ea: ExcalidrawAutomate;\n excalidrawFile: TFile; //the file being loaded\n view: ExcalidrawView;\n}) => Promise;\n${String.fromCharCode(96,96,96)}`,"1.8.21":'\n## Quality of Life improvements\n- Dynamic Styling (see plugin settings / Display). When Dynamic Styling is enabled it fixes Excalidraw issues with the Minimal Theme\n- New "Invert Colors" script\n\n
\n\n
\n\n### Note\nThe few of you, that are using the Dynamic Styling Templater script, please remove it and restart Obsidian.\n',"1.8.20":"\n## Fixed\n- Excalidraw froze Obsidian in certain rare situations [#1054](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1054)\n- File loading error [#1062](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1062)\n- Embedded images in markdown documents no longer have the line on the side. Image sizing works better. [#1059](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1059)\n- Locked elements will not show a hover preview [#1060](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1060)\n- CTRL/CMD + K correctly triggers add link [#1056](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1056)\n\n## New\n- Grid color adjusts to the view background color\n\nI'm sorry, but the sticky note editing issue on Android with the on-screen keyboard has still not been resolved. If you also experience this error, please help raise the priority with the core Excalidraw team by commenting on this issue: [#6330](https://github.com/excalidraw/excalidraw/issues/6330)\n","1.8.19":"\n## Fixed: Text wrapping issue in sticky notes\n\nI fixed an issue where text would wrap differently and words would disappear during text editing in sticky notes. You can check out the details on [GitHub #6318](https://github.com/excalidraw/excalidraw/issues/6331).\n\nI am aware of three additional issues related to container text editing that are still open. I apologize for any inconvenience caused by the recent change in how text size is calculated on Excalidraw.com, which has had a knock-on effect on Obsidian. I am actively working to address the following issues:\n\n- Pinch zooming while editing text in a text container [GitHub #6331](https://github.com/excalidraw/excalidraw/issues/6331)\n- Container text jumps on edit on Android with on-screen keyboard [GitHub #6330](https://github.com/excalidraw/excalidraw/issues/6330)\n- Shadow text when editing text containers without a keyboard on iOS [GitHub #6329](https://github.com/excalidraw/excalidraw/issues/6329)\n\nThank you for your patience while I work on resolving these issues.\n","1.8.18":`\n## Fixed\n- Text scaling issue introduced in 1.8.17\n- [#1043](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1043): Error handling when ${String.fromCharCode(96)}onCanvasColorChangeHook${String.fromCharCode(96)} is executed. This is used in the [Dynamic Styling Script](https://youtu.be/LtR04fNTKTM). \n`,"1.8.17":'\n## New from Excalidraw.com\n- Improved text wrapping in the ellipse and diamond shapes [6172](https://github.com/excalidraw/excalidraw/pull/6172)\n\n## New\n- Updated slideshow script\n\n
\n\n
\n\n## Fixed: \n- "Save to..." in the Stencil Library menu now works as expected [#1032](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1032)\n',"1.8.16":'\n**!!! Modifier keys have changed, please review the table below !!!**\n[Click this to see the new shortcuts overview image](https://raw.githubusercontent.com/zsviczian/obsidian-excalidraw-plugin/master/images/excalidraw-modifiers.png)\n\n## Fixed \n- This version was extensively tested and developed on MacOS to remove usability issues.\n- New command palette action to create a new drawing in a new tab\n- Modifier keys to open links in the active window, splitting the current view to the right, in a new tab, or in a popout window now behave consistently both in Excalidraw and when clicking a drawing that is embedded in a markdown note.\n- Drag & Drop properly works from within Obsidian, from a web browser, and from the OS file explorer\n\n
\n\n
\n',"1.8.14":"\n## Fixed\n- text element link gets deleted when the drawing is reloaded\n","1.8.13":'\n## Fixed\n- When changing a text element in markdown mode, the change seem to have showed up when switching back to Excalidraw mode, but then lost these changes when loading the file the next time.\n- Scrolling through a page that has embedded drawings on Obsidian Mobile accidently opens the drawing in Excalidraw when touching the image. Now you need to press and hold to open the image in Excalidraw. [#1003](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/1003)\n- The scrollbar is no longer visible when presenting using the SlideShow script\n- Stroke properties could not be changed when custom pen settings had "Stroke & fill applies to: All shapes". It works now.\n\n## QoL\n- Custom pens will remember the stroke changes until you press the pen preset button again.\n - This is a bit hard to explain, let me try... Essentially, when you use a custom pen, it will keep the changes you made to the pen (like changing the stroke width) until you press the pen-prereset button again. So, for example, if you\'re using a mind mapping custom pen and change its color, and then switch to a different tool like text, when you switch back to the freedraw tool using the Excalidraw tools panel, the pen will still have the same color you set earlier, but if you press the mind mapping pen-preset button, it will default back to your custom pen settings including your preset color.\n- Added new buttons to load current stroke color and background color in the pen settings dialog. Also added an edit box so you can configure any valid color string (including with transparency) for pen stroke and background colors. [#991](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/991)\n',"1.8.11":'\n
\n\n
\n\n# New\n- Support for referencing images from the internet in Excalidraw drawings, including YouTube thumbnail support. [#913](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/913)\n - Link to images on the internet without creating a copy in your Vault by holding down the CTRL key while dropping the link or image.\n - Automatic conversion of image URLs and YouTube links into image elements with original links added as a link on the element when pasting. Note, that if you only want to paste the plain text link (not the image), first double-click the canvas to start a new text element, then paste the link.\n- Two new options added to plugin settings:\n - Make mouse wheel zoom by default [#474](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/474)\n - Allow pinch zoom in pen mode [#828](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/828)\n- Update to the [Set Grid](https://github.com/zsviczian/obsidian-excalidraw-plugin/blob/master/ea-scripts/Set%20Grid.svg) script now saves the grid setting for the current file.\n',"1.8.10":'\n
\n\n
\n\n# QoL improvements\n- You can structure icons in the Obsidian tools panel by moving scripts to folders\n![image|300](https://user-images.githubusercontent.com/14358394/212389592-306130d0-209a-49df-99bb-c538f2155b23.png)\n- I added useful actions to the hamburger menu in both tray-mode and normal-mode. \n![image|150](https://user-images.githubusercontent.com/14358394/212534508-9107fd19-27ab-4415-8abc-bc97c73afc0b.png)\n- I added a new Export Image dialog. You can access the new export screen from the hamburger-menu\n![image|200](https://user-images.githubusercontent.com/14358394/212534654-7a479e23-8d5d-452e-9a18-a9896278aa27.png)\n- Links in help now point to Obsidian-Excalidraw relevant content.\n- I added a welcome screen\n![image|150](https://user-images.githubusercontent.com/14358394/212534568-3cd1e8a1-5b20-4a30-96e4-40d7dac57e33.png)\n- I updated the alternative dark mode / dynamic styling [script](https://gist.github.com/zsviczian/c7223c5b4af30d5c88a0cae05300305c)\n',"1.8.9":"\n# Minor QoL improvements\n- When you open a second drawing in the same Excalidraw view (i.e. by navigating a link) and make a change to this drawing, and then press UNDO, the entire drawing disappeared. Redo brought the image back, however, this behavior was frustrating. Not anymore...\n- On iPad\n - when you open the command palette, autozoom resized the drawing. If the Obsidian command palette or some other modal window is shown Excalidraw will not resize the view.\n - when you add a link to the drawing using the Command Palette, sometimes the link was added in a far corner of the drawing outside the current view area. This should be fixed now.","1.8.8":`\n
\n\n
\n\n# New\n- The plugin now includes support for [Perfect Freehand](https://perfect-freehand-example.vercel.app/) pen-options. I've also added a new [Alternative Pens](https://github.com/zsviczian/obsidian-excalidraw-plugin/blob/master/ea-scripts/Alternative%20Pens.md) script.\n- Embed scene in exported PNG and SVG images [#860](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/860). This means that the export will be a normal PNG or SVG image with the added functionality that if someone loads the image into excalidraw.com it will open as a normal excalidraw file.\n - I've added 2 new Command Palette actions (export PNG, export SVG with embedded scene).\n - If you SHIFT click ${String.fromCharCode(96)} Save as PNG (or SVG)${String.fromCharCode(96)} in the workspace-tab menu, Excalidraw will embed the scene in the export.\n- I updated the [Organic Line](https://github.com/zsviczian/obsidian-excalidraw-plugin/blob/master/ea-scripts/Organic%20Line.md) script. It has an improved thick-to-thin look and a new thin-to-thick-to-thin line type.\n\n# Fixed\n- Intelligent image width setting [#955](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/955). Before this change, when the embedded image was small, the image would be extended to meet the image width setting in plugin settings. From now on, if the image is smaller than max-width, it will only extend to max-width. You can still set 100% width using custom CSS. See more on that [here](https://github.com/zsviczian/obsidian-excalidraw-plugin#embedded-images).\n\n# New in ExcalidrawAutomate\n- I added the ${String.fromCharCode(96)} plaintext${String.fromCharCode(96)} parameter to ${String.fromCharCode(96)}ExcalidrawAutomate.create${String.fromCharCode(96)} . Using this, you can add some text below the frontmatter but above the ${String.fromCharCode(96)}# Text Elements${String.fromCharCode(96)} section. Use this for example to add metadata to your file. (e.g. I use this in my Daily Quote template to add a Dataview field for the ${String.fromCharCode(96)}Author::${String.fromCharCode(96)} and add the quote with a standard block reference, so I can easily reference it in other files. I also add the ${String.fromCharCode(96)}#quote${String.fromCharCode(96)} tag to the file using this.)\n- The script running in the ScriptEngine now also receives the ${String.fromCharCode(96)}TFile${String.fromCharCode(96)} object for the script itself. You can access this object during execution via the ${String.fromCharCode(96)}utils.scriptFile${String.fromCharCode(96)} variable. \n`,"1.8.7":'\n## New from Excalidraw.com\n- Support shrinking text containers to their original height when text is removed [#6025](https://github.com/excalidraw/excalidraw/pull/6025)\n
\n\n
\n\n## Fixed\n- removed the white background when editing arrow-label [#6033](https://github.com/excalidraw/excalidraw/pull/6033)\n- Minor style tweaks\n - for embedding Excalidraw into Obsidian Canvas. e.g. dragging no longer accidentally creates an image copy of the drawing, and\n - style tweaks on the Excalidraw canvas\n\n## New\n- If you set a different text color and sticky note border color, now if you change the border color, the text color will not be changed.\n',"1.8.6":`\n## New from Excalidraw.com:\n- Better default radius for rectangles [#5553](https://github.com/excalidraw/excalidraw/pull/5553). Existing drawings will look unchanged, this applies only to new rectangles.\n![image|200](https://user-images.githubusercontent.com/5153846/206264345-59fd7436-e87b-4bc9-ade8-9e6f6a6fd8c1.png)\n> [!attention]- ExcalidrawAutomate technical details\n> - ${String.fromCharCode(96)}strokeSharpness${String.fromCharCode(96)} is now deprecated\n> - use roundness instead\n> - ${String.fromCharCode(96)}roundness === null${String.fromCharCode(96)} is legacy ${String.fromCharCode(96)}strokeSharpness = "sharp"${String.fromCharCode(96)}\n> - ${String.fromCharCode(96)}roundness = { type: RoundnessType; value?: number }${String.fromCharCode(96)}\n> - type: 1, LEGACY, type:2 PROPORTIONAL_RADIUS, type:3 ADAPTIVE_RADIUS: 3\n> - value:\n> - Radius represented as % of element's largest side (width/height).\n> DEFAULT_PROPORTIONAL_RADIUS = 0.25;\n> - Fixed radius for the ADAPTIVE_RADIUS algorithm. In pixels.\n> DEFAULT_ADAPTIVE_RADIUS = 32;\n\n## New\n- For Obsidian 1.1.6 and above\n - Improved embedding into Obsidian Canvas\n - Improved embedding into Markdown documents\n- Added setting under ${String.fromCharCode(96)}Display/Default mode when opening Excalidraw${String.fromCharCode(96)} to always open the drawing in view mode on Mobile, but in normal mode on desktop. [#939](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/939)\n\n## Fixed\n- Zoom reset tooltip appears twice [#942](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/942)\n- Hid export library from library menu as it does not work due to Obsidian limitations. Use the command palette export library instead.\n- Arrow with label did not get exported and embedded correctly [#941](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/941)\n![image|200](https://user-images.githubusercontent.com/22638687/207845868-b352ddb1-7994-4f13-a0b2-f2e19bd72935.png)\n`,"1.8.4":'\n## New from Excalidraw.com\n- Labels on Arrows!!! [#5723](https://github.com/excalidraw/excalidraw/pull/5723)\n - To add a label press "Enter" or "Double click" on the arrow\n - Use "Cmd/Ctrl+double click" to enter the line editor\n\n
\n\n
\n\n## New\n- **Changed behavior**: In the Obsidian markdown editor clicking an Excalidraw image will not open the image (to avoid accidentally opening the image on a tablet). To open a drawing for editing in Excalidraw double click or long-tap on it. [#920](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/920)\n\n## Fixed \n- Text stroke color is not honored when pasting a HEX color string to an Excalidraw canvas open in an Obsidian popout window [#921](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/921)\n- The new [multi-line >> multi-element paste behavior](https://github.com/excalidraw/excalidraw/pull/5786) introduced in the previous release did not work as expected in Obsidian. Now it does.\n',"1.8.2":`\nIntroducing the [Excalidraw Slideshow Script](https://github.com/zsviczian/obsidian-excalidraw-plugin/blob/master/ea-scripts/Slideshow.md) - available in the script store\n
\n\n
\n\n## Fixed\n- Obsidian tools panel gets misplaced after switching Obsidian workspace tabs\n\n## New in ExcalidrawAutomate\n- changed ${String.fromCharCode(96)}viewToggleFullScreen(forceViewMode: boolean = false): void${String.fromCharCode(96)}: the function will toggle view mode on when going to full screen and view mode off when terminating full screen.\n- new functions\n${String.fromCharCode(96,96,96)}typescript\nsetViewModeEnabled(enabled: boolean):void;\nviewUpdateScene(\n scene: {\n elements?: ExcalidrawElement[];\n appState?: AppState;\n files?: BinaryFileData;\n commitToHistory?: boolean;\n },\n restore: boolean = false,\n ):void;\nviewZoomToElements(\n selectElements: boolean,\n elements: ExcalidrawElement[]\n ):void;\n${String.fromCharCode(96,96,96)}\n\n`,"1.8.1":`\n## New and fixes from Excalidraw.com\n- New text paste behavior. Pasting multiline text will generate separate text elements unless you hold down the shift button while pasting [#5786](https://github.com/excalidraw/excalidraw/pull/5786)\n- line editor fixes [#5927](https://github.com/excalidraw/excalidraw/pull/5927)\n\n## Fixed\n- The Command Palette "Insert link" action now inserts the new link at the top drawing layer, not at the bottom.\n- Updated, hopefully, better organized, Plugin Readme.\n\n## New\n- Second attempt at moving to React 18. This upgrade is required to maintain alignment with the core Excalidraw product and to continue to benefit from Excalidraw.com enhancements.\n- Added options to Plugin Settings\n - to disable autozoom when loading a drawing for the first time [#907](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/907)\n - to modify autosave interval. You can now set an autosave interval for desktop and for mobile [#888](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/888)\n\n## New in ExcalidrawAutomate\n- Published the obsidian_module on the ExcalidrawAutomate object. ${String.fromCharCode(96)}ExcalidrawAutomate.obsidian${String.fromCharCode(96)}. Publishing this object will give script developers increased flexibility and control over script automation.\n`,"1.8.0":'\n
\n\n
\n\n## New\n- Optical Character Recognition (OCR). Introducing the MVP (minimum viable product) release of the integration of [Taskbone](https://taskbone.com) OCR into Excalidraw. See the new scan button on the Obsidian tools panel.\n- New and improved full-screen mode\n - Activate using the Obsidian tools panel, the Obsidian Command Palette, or the Alt+F11 shortcut\n - The ESC key no longer closes full-screen\n - Full-screen mode works properly on iOS as well\n- Improved Icon visibility on the Obsidian tools panel\n- Added 3 additional buttons to the tools panel\n - Force save\n - Open link (useful on Mobile devices). In the case of LaTeX equations, the button opens the equation properties.\n - Open the link in a new pane. In the case of embedded markdown documents, the button opens the embed properties.\n\n## Fixed\n- The [deconstruct selected elements into a new drawing](https://github.com/zsviczian/obsidian-excalidraw-plugin/blob/master/ea-scripts/Deconstruct%20selected%20elements%20into%20new%20drawing.md) script now also correctly decomposes transcluded text elements.\n',"1.7.30":"\nFix:\n- Forcing the embedded image to always scale to 100% (a feature introduced in [1.7.26](https://github.com/zsviczian/obsidian-excalidraw-plugin/releases/tag/1.7.26)) scaled the embedded excalidraw drawings incorrectly on devices with a pixel ratio of 2 or 3 (e.g. iPads). This is now fixed, however, this fix might retrospectively impact drawings that use this feature. Sorry for that.\n","1.7.29":"\n- This is a big update that accommodates the **UI redesign** on Excalidraw.com [#5780](https://github.com/excalidraw/excalidraw/pull/5780). The change on the surface may seem superficial, however, I had to tweak a number of things to make it work in Obsidian. I hope I found everything that broke and fixed it, if not, I'll try to fix it quickly...\n- This update also comes with changes under the hood that **fix issues with Excalidraw Automate** - paving the way for further scripts, plus some smaller bug fixes.\n- I **reworked text wrapping**. In some cases, text wrapping in SVG exports looked different compared to how the text looked in Excalidraw. This should now be fixed.\n- If you are using the **Experimental Dynamic Styling** of the Excalidraw Toolbar, then I recommend updating your styling script following base on [this](https://gist.github.com/zsviczian/c7223c5b4af30d5c88a0cae05300305c)\n","1.7.27":'## New\n- Import SVG drawing as an Excalidraw object. [#679](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/679)\n\n
\n\n
\n\n## Fixed\n- Large drawings freeze on the iPad when opening the file. I implemented a workaround whereby Excalidraw will avoid zoom-to-fit drawings with over 1000 elements. [#863](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/863)\n- Reintroduced copy/paste to the context menu\n',"1.7.26":'## Fixed\n- Transcluded block with a parent bullet does not embed sub-bullet [#853](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/853)\n- Transcluded text will now exclude ^block-references at end of lines\n- Phantom duplicates of the drawing appear when "zoom to fit" results in a zoom value below 10% and there are many objects on the canvas [#850](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/850)\n- CTRL+Wheel will increase/decrease zoom in steps of 5% matching the behavior of the "+" & "-" zoom buttons.\n- Latest updates from Excalidarw.com\n - Freedraw flip not scaling correctly [#5752](https://github.com/excalidraw/excalidraw/pull/5752)\n - Multiple elements resizing regressions [#5586](https://github.com/excalidraw/excalidraw/pull/5586)\n\n## New - power user features\n- Force the embedded image to always scale to 100%. Note: this is a very niche feature with a very particular behavior that I built primarily for myself (even more so than other features in Excalidraw Obsidian - also built primarily for myself 😉)... This will reset your embedded image to 100% size every time you open the Excalidraw drawing, or in case you have embedded an Excalidraw drawing on your canvas inserted using this function, every time you update the embedded drawing, it will be scaled back to 100% size. This means that even if you resize the image on the drawing, it will reset to 100% the next time you open the file or you modify the original embedded object. This feature is useful when you decompose a drawing into separate Excalidraw files, but when combined onto a single canvas you want the individual pieces to maintain their actual sizes. I use this feature to construct Book-on-a-Page summaries from atomic drawings.\n- I added an action to the command palette to temporarily disable/enable Excalidraw autosave. When autosave is disabled, Excalidraw will still save your drawing when changing to another Obsidian window, but it will not save every 10 seconds. On a mobile device (but also on a desktop) this can lead to data loss if you terminate Obsidian abruptly (i.e. swipe the application away, or close Obsidian without first closing the drawing). Use this feature if you find Excalidraw laggy.'};class ReleaseNotes extends obsidian_module.Modal{constructor(e,t,A){super(e),this.plugin=t,this.version=A}onOpen(){var e;this.containerEl.classList.add("excalidraw-release"),this.titleEl.setText(`Welcome to Excalidraw ${null!==(e=this.version)&&void 0!==e?e:""}`),this.createForm()}async onClose(){this.contentEl.empty(),await this.plugin.loadSettings(),this.plugin.settings.previousRelease=PLUGIN_VERSION,await this.plugin.saveSettings()}async createForm(){let e=this.plugin.settings.previousRelease;e=this.version===e?"0.0.0":e;const t=this.version?Object.keys(RELEASE_NOTES).filter((t=>"Intro"===t||isVersionNewerThanOther(t,e))).map((e=>`${"Intro"===e?"":`# ${e}\n`}${RELEASE_NOTES[e]}`)).slice(0,10).join("\n\n---\n"):FIRST_RUN;await obsidian_module.MarkdownRenderer.renderMarkdown(t,this.contentEl,"",this.plugin),this.contentEl.createEl("p",{text:""},(e=>{e.style.textAlign="right",e.createEl("button",{text:"Close"}).onclick=()=>this.close()}))}}class ExportDialog extends obsidian_module.Modal{constructor(e,t,A){super(app),this.plugin=e,this.view=t,this.file=A,this.dirty=!1,this.hasSelectedElements=!1,this.ea=getEA(this.view),this.api=this.ea.getExcalidrawAPI(),this.padding=getExportPadding(this.plugin,this.file),this.scale=getPNGScale(this.plugin,this.file),this.theme=getExportTheme(this.plugin,this.file,this.api.getAppState().theme),this.boundingBox=this.ea.getBoundingBox(this.ea.getViewElements()),this.embedScene=!1,this.exportSelectedOnly=!1,this.saveToVault=!0,this.transparent=!getWithBackground(this.plugin,this.file),this.saveSettings=!1}onOpen(){this.containerEl.classList.add("excalidraw-release"),this.titleEl.setText("Export Image"),this.hasSelectedElements=this.view.getViewSelectedElements().length>0,this.selectedOnlySetting.setVisibility(this.hasSelectedElements)}async onClose(){this.dirty=this.saveSettings}async createForm(){let e,t;this.contentEl.createEl("h1",{text:"Image settings"}),this.contentEl.createEl("p",{text:"Transparency only affects PNGs. Excalidraw files can only be exported outside the Vault. PNGs copied to clipboard may not include the scene."});const A=()=>{const e=Math.round(this.scale*this.boundingBox.width+2*this.padding),t=Math.round(this.scale*this.boundingBox.height+2*this.padding);return fragWithHTML(`The lager the scale, the larger the image.
Scale: ${this.scale}
Image size: ${e}x${t}`)},i=()=>fragWithHTML(`Current image padding is ${this.padding}`);t=new obsidian_module.Setting(this.contentEl).setName("Image padding").setDesc(i()).addSlider((n=>{n.setLimits(0,50,1).setValue(this.padding).onChange((n=>{this.padding=n,e.setDesc(A()),t.setDesc(i())}))})),e=new obsidian_module.Setting(this.contentEl).setName("PNG Scale").setDesc(A()).addSlider((t=>t.setLimits(.5,5,.5).setValue(this.scale).onChange((t=>{this.scale=t,e.setDesc(A())})))),new obsidian_module.Setting(this.contentEl).setName("Export theme").addDropdown((e=>e.addOption("light","Light").addOption("dark","Dark").setValue(this.theme).onChange((e=>{this.theme=e})))),new obsidian_module.Setting(this.contentEl).setName("Background color").addDropdown((e=>e.addOption("transparent","Transparent").addOption("with-color","Use scene background color").setValue(this.transparent?"transparent":"with-color").onChange((e=>{this.transparent="transparent"===e})))),new obsidian_module.Setting(this.contentEl).setName("Save or one-time settings?").addDropdown((e=>e.addOption("save","Save these settings as the preset for this image").addOption("one-time","These are one-time settings").setValue(this.saveSettings?"save":"one-time").onChange((e=>{this.saveSettings="save"===e})))),this.contentEl.createEl("h1",{text:"Export settings"}),new obsidian_module.Setting(this.contentEl).setName("Embed the Excalidraw scene in the exported file?").addDropdown((e=>e.addOption("embed","Embed scene").addOption("no-embed","Do not embed scene").setValue(this.embedScene?"embed":"no-embed").onChange((e=>{this.embedScene="embed"===e})))),DEVICE.isDesktop&&new obsidian_module.Setting(this.contentEl).setName("Where to save the image?").addDropdown((e=>e.addOption("vault","Save image to your Vault").addOption("outside","Export image outside your Vault").setValue(this.saveToVault?"vault":"outside").onChange((e=>{this.saveToVault="vault"===e})))),this.selectedOnlySetting=new obsidian_module.Setting(this.contentEl).setName("Export entire scene or just selected elements?").addDropdown((e=>e.addOption("all","Export entire scene").addOption("selected","Export selected elements").setValue(this.exportSelectedOnly?"selected":"all").onChange((e=>{this.exportSelectedOnly="selected"===e}))));const n=this.contentEl.createDiv({cls:"excalidraw-prompt-buttons-div"});n.createEl("button",{text:"PNG to File",cls:"excalidraw-prompt-button"}).onclick=()=>{this.saveToVault?this.view.savePNG(this.view.getScene(this.hasSelectedElements&&this.exportSelectedOnly)):this.view.exportPNG(this.embedScene,this.hasSelectedElements&&this.exportSelectedOnly),this.close()},n.createEl("button",{text:"SVG to File",cls:"excalidraw-prompt-button"}).onclick=()=>{this.saveToVault?this.view.saveSVG(this.view.getScene(this.hasSelectedElements&&this.exportSelectedOnly)):this.view.exportSVG(this.embedScene,this.hasSelectedElements&&this.exportSelectedOnly),this.close()},n.createEl("button",{text:"Excalidraw",cls:"excalidraw-prompt-button"}).onclick=()=>{this.view.exportExcalidraw(this.hasSelectedElements&&this.exportSelectedOnly),this.close()},DEVICE.isDesktop&&(n.createEl("button",{text:"PNG to Clipboard",cls:"excalidraw-prompt-button"}).onclick=()=>{this.view.exportPNGToClipboard(this.embedScene,this.hasSelectedElements&&this.exportSelectedOnly),this.close()})}}const TOOLS_PANEL_WIDTH=228;class ToolsPanel extends React__namespace.Component{constructor(e){super(e),this.pos1=0,this.pos2=0,this.pos3=0,this.pos4=0,this.penDownX=0,this.penDownY=0,this.previousWidth=0,this.previousHeight=0,this.onRightEdge=!1,this.onBottomEdge=!1;const t=e.view.plugin.getPackage(e.view.ownerWindow).react;this.containerRef=t.createRef(),this.state={visible:e.visible,top:50,left:200,theme:"dark",excalidrawViewMode:!1,minimized:!1,isDirty:!1,isFullscreen:!1,isPreviewMode:!0,scriptIconMap:{}}}updateScriptIconMap(e){this.setState((()=>({scriptIconMap:e})))}setPreviewMode(e){this.setState((()=>({isPreviewMode:e})))}setFullscreen(e){this.setState((()=>({isFullscreen:e})))}setDirty(e){this.setState((()=>({isDirty:e})))}setExcalidrawViewMode(e){this.setState((()=>({excalidrawViewMode:e})))}toggleVisibility(e){this.setTopCenter(e),this.setState((e=>({visible:!e.visible})))}setTheme(e){this.setState((t=>({theme:e})))}setTopCenter(e){this.setState((()=>({left:(this.containerRef.current.clientWidth-228-(e?0:232))/2+this.containerRef.current.parentElement.offsetLeft+(e?0:232),top:64+this.containerRef.current.parentElement.offsetTop})))}updatePosition(e=0,t=0){this.setState((()=>{const{offsetTop:A,offsetLeft:i,clientWidth:n,clientHeight:a}=this.containerRef.current.firstElementChild,r=A-e,s=i-t,{clientWidth:o,clientHeight:l,offsetTop:c,offsetLeft:d}=this.containerRef.current.parentElement;return this.previousHeight=l,this.previousWidth=o,this.onBottomEdge=r>=l-a+c,this.onRightEdge=s>=o-n+d,{top:r{e.preventDefault(),Math.abs(this.penDownX-this.pos3)>5||Math.abs(this.penDownY-this.pos4)>5||this.setState((e=>({minimized:!e.minimized})))},onPointerDown:e=>{const t=e=>{e.preventDefault(),this.pos1=this.pos3-e.clientX,this.pos2=this.pos4-e.clientY,this.pos3=e.clientX,this.pos4=e.clientY,this.updatePosition(this.pos2,this.pos1)},A=()=>{var e,i;null===(e=this.props.view.ownerDocument)||void 0===e||e.removeEventListener("pointerup",A),null===(i=this.props.view.ownerDocument)||void 0===i||i.removeEventListener("pointermove",t)};e.preventDefault(),this.penDownX=this.pos3=e.clientX,this.penDownY=this.pos4=e.clientY,this.props.view.ownerDocument.addEventListener("pointerup",A),this.props.view.ownerDocument.addEventListener("pointermove",t)}},React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 228 26"},React__namespace.createElement("path",{stroke:"var(--icon-fill-color)",strokeWidth:"2",d:"M40,7 h148 M40,13 h148 M40,19 h148"}))),React__namespace.createElement("div",{className:"Island App-menu__left scrollbar",style:{maxHeight:"350px",width:"initial","--padding":2,display:this.state.minimized?"none":"block"}},React__namespace.createElement("div",{className:"panelColumn"},React__namespace.createElement("fieldset",null,React__namespace.createElement("legend",null,"Utility actions"),React__namespace.createElement("div",{className:"buttonList buttonListIcon"},React__namespace.createElement(ActionButton,{key:"scriptEngine",title:t$d("INSTALL_SCRIPT_BUTTON"),action:()=>{new ScriptInstallPrompt(this.props.view.plugin).open()},icon:ICONS.scriptEngine,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"release-notes",title:t$d("READ_RELEASE_NOTES"),action:()=>{new ReleaseNotes(this.props.view.app,this.props.view.plugin,PLUGIN_VERSION).open()},icon:ICONS.releaseNotes,view:this.props.view}),null===this.state.isPreviewMode?React__namespace.createElement(ActionButton,{key:"convert",title:t$d("CONVERT_FILE"),action:()=>{this.props.view.convertExcalidrawToMD()},icon:ICONS.convertFile,view:this.props.view}):React__namespace.createElement(ActionButton,{key:"viewmode",title:this.state.isPreviewMode?t$d("PARSED"):t$d("RAW"),action:()=>{this.state.isPreviewMode?this.props.view.changeTextMode(TextMode.raw):this.props.view.changeTextMode(TextMode.parsed)},icon:this.state.isPreviewMode?ICONS.rawMode:ICONS.parsedMode,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"tray-mode",title:t$d("TRAY_MODE"),action:()=>{this.props.view.toggleTrayMode()},icon:ICONS.trayMode,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"fullscreen",title:this.state.isFullscreen?t$d("EXIT_FULLSCREEN"):t$d("GOTO_FULLSCREEN"),action:()=>{this.state.isFullscreen?this.props.view.exitFullscreen():this.props.view.gotoFullscreen()},icon:this.state.isFullscreen?ICONS.exitFullScreen:ICONS.gotoFullScreen,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"search",title:t$d("SEARCH"),action:()=>{search(this.props.view)},icon:ICONS.search,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"ocr",title:t$d("RUN_OCR"),action:e=>{this.props.view.plugin.settings.taskboneEnabled?this.props.view.plugin.taskbone.getTextForView(this.props.view,isCTRL(e)):new obsidian_module.Notice("Taskbone OCR is not enabled. Please go to plugins settings to enable it.",4e3)},icon:ICONS.ocr,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"openLink",title:t$d("OPEN_LINK_CLICK"),action:e=>{const t=new MouseEvent("click",{ctrlKey:e.ctrlKey||!(DEVICE.isIOS||DEVICE.isMacOS),metaKey:e.metaKey||DEVICE.isIOS||DEVICE.isMacOS,shiftKey:e.shiftKey,altKey:e.altKey});this.props.view.handleLinkClick(t)},icon:ICONS.openLink,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"openLinkProperties",title:t$d("OPEN_LINK_PROPS"),action:()=>{const e=new MouseEvent("click",{ctrlKey:!0,metaKey:!0,shiftKey:!1,altKey:!1});this.props.view.handleLinkClick(e)},icon:ICONS.openLinkProperties,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"save",title:t$d("FORCE_SAVE"),action:()=>{this.props.view.forceSave()},icon:saveIcon(this.state.isDirty),view:this.props.view}))),React__namespace.createElement("fieldset",null,React__namespace.createElement("legend",null,"Export actions"),React__namespace.createElement("div",{className:"buttonList buttonListIcon"},React__namespace.createElement(ActionButton,{key:"lib",title:t$d("DOWNLOAD_LIBRARY"),action:()=>{this.props.view.plugin.exportLibrary()},icon:ICONS.exportLibrary,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"exportIMG",title:t$d("EXPORT_IMAGE"),action:()=>{const e=this.props.view;e.exportDialog||(e.exportDialog=new ExportDialog(e.plugin,e,e.file),e.exportDialog.createForm()),e.exportDialog.open()},icon:ICONS.ExportImage,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"md",title:t$d("OPEN_AS_MD"),action:()=>{this.props.view.openAsMarkdown()},icon:ICONS.switchToMarkdown,view:this.props.view}))),React__namespace.createElement("fieldset",null,React__namespace.createElement("legend",null,"Insert actions"),React__namespace.createElement("div",{className:"buttonList buttonListIcon"},React__namespace.createElement(ActionButton,{key:"image",title:t$d("INSERT_IMAGE"),action:()=>{this.props.centerPointer(),this.props.view.plugin.insertImageDialog.start(this.props.view)},icon:ICONS.insertImage,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"pdf",title:t$d("INSERT_PDF"),action:()=>{this.props.centerPointer(),new InsertPDFModal(this.props.view.plugin,this.props.view).open()},icon:ICONS.insertPDF,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"insertMD",title:t$d("INSERT_MD"),action:()=>{this.props.centerPointer(),this.props.view.plugin.insertMDDialog.start(this.props.view)},icon:ICONS.insertMD,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"latex",title:t$d("INSERT_LATEX"),action:e=>{isALT(e)?this.props.view.openExternalLink("https://youtu.be/r08wk-58DPk"):(this.props.centerPointer(),insertLaTeXToView(this.props.view))},icon:ICONS.insertLaTeX,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"link",title:t$d("INSERT_LINK"),action:()=>{this.props.centerPointer(),this.props.view.plugin.insertLinkDialog.start(this.props.view.file.path,this.props.view.addText)},icon:ICONS.insertLink,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"link-to-element",title:t$d("INSERT_LINK_TO_ELEMENT"),action:e=>{isALT(e)?this.props.view.openExternalLink("https://youtu.be/yZQoJg2RCKI"):this.props.view.copyLinkToSelectedElementToClipboard(isCTRL(e)?"group=":isSHIFT(e)?"area=":"")},icon:ICONS.copyElementLink,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"import-svg",title:t$d("IMPORT_SVG"),action:e=>{this.props.view.plugin.importSVGDialog.start(this.props.view)},icon:ICONS.importSVG,view:this.props.view}))),this.renderScriptButtons(!1),this.renderScriptButtons(!0)))))}renderScriptButtons(e){if(0===Object.keys(this.state.scriptIconMap).length)return"";const t=`${this.props.view.plugin.settings.scriptFolderPath}/Downloaded/`,A=A=>e?A.startsWith(t):!A.startsWith(t);if(0===Object.keys(this.state.scriptIconMap).filter((e=>A(e))).length)return"";const i=new Set;Object.keys(this.state.scriptIconMap).filter((e=>A(e))).forEach((e=>i.add(this.state.scriptIconMap[e].group)));const n=Array.from(i).sort(((e,t)=>e>t?1:-1));return n.push(n.shift()),React__namespace.createElement(React__namespace.Fragment,null,n.map(((t,A)=>React__namespace.createElement("fieldset",{key:`${t}-${A}`},React__namespace.createElement("legend",null,e?t:""===t?"User":"User/"+t),React__namespace.createElement("div",{className:"buttonList buttonListIcon"},Object.entries(this.state.scriptIconMap).filter((([e,A])=>A.group===t)).sort().map((([e,t])=>React__namespace.createElement(ActionButton,{key:e,title:t.name,action:async()=>{const t=this.props.view,A=t.plugin,i=app.vault.getAbstractFileByPath(e);i&&i instanceof obsidian_module.TFile&&A.scriptEngine.executeScript(t,await app.vault.read(i),A.scriptEngine.getScriptName(i),i)},longpress:async()=>{const A=this.props.view,i=A.excalidrawAPI,n=A.plugin;await n.loadSettings();const a=n.settings.pinnedScripts.indexOf(e);a>-1?(n.settings.pinnedScripts.splice(a,1),null==i||i.setToast({message:`Pin removed: ${t.name}`,duration:3e3,closable:!0})):(n.settings.pinnedScripts.push(e),null==i||i.setToast({message:`Pinned: ${t.name}`,duration:3e3,closable:!0})),await n.saveSettings(),app.workspace.getLeavesOfType("excalidraw").forEach((e=>{e.view instanceof ExcalidrawView&&e.view.updatePinnedScripts()}))},icon:t.svgString?stringToSVG(t.svgString):ICONS.cog,view:this.props.view}))))))))}}const getElementsAtPointer=(e,t,A)=>t.filter((t=>{if(A&&t.type!==A)return!1;if(t.locked)return!1;const[i,n,a,r]=rotatedDimensions(t);return i<=e.x&&i+a>=e.x&&n<=e.y&&n+r>=e.y})),getTextElementAtPointer=(e,t)=>{const A=t.excalidrawAPI;if(!A)return{id:null,text:null};const i=getElementsAtPointer(e,A.getSceneElements(),"text");if(0==i.length)return{id:null,text:null};if(1===i.length)return{id:i[0].id,text:i[0].text};const n=i.filter((e=>{const A=t.textMode===TextMode.parsed?t.excalidrawData.getRawText(e.id):e.text;return!!A&&(!!A.match(REG_LINKINDEX_HYPERLINK)||!!REGEX_LINK.getRes(A).next().value)}));return 0==n.length?{id:i[0].id,text:i[0].text}:{id:n[0].id,text:n[0].text}},getImageElementAtPointer=(e,t)=>{const A=t.excalidrawAPI;if(!A)return;const i=getElementsAtPointer(e,A.getSceneElements(),"image");return 0===i.length?{id:null,fileId:null}:i.length>=1?{id:i[0].id,fileId:i[0].fileId}:void 0},getElementWithLinkAtPointer=(e,t)=>{const A=t.excalidrawAPI;if(!A)return;const i=getElementsAtPointer(e,A.getSceneElements()).filter((e=>e.link));return 0===i.length?{id:null,text:null}:i.length>=1?{id:i[0].id,text:i[0].link}:void 0},setDynamicStyle=(e,t,A,i)=>{var n,a,r,s,o,l,c,d,h,u,g,p,m,w;if("none"===i){null===(n=t.excalidrawContainer)||void 0===n||n.removeAttribute("style"),setTimeout((()=>t.updateScene({appState:{dynamicStyle:""}})));const e=null===(s=null===(r=null===(a=t.toolsPanelRef)||void 0===a?void 0:a.current)||void 0===r?void 0:r.containerRef)||void 0===s?void 0:s.current;if(e){let t=e.getAttribute("style");t=t.replace(/\-\-color\-primary.*/,""),e.setAttribute("style",t)}return}t.ownerDocument;const f="light"===(null===(c=null===(l=null===(o=null==t?void 0:t.excalidrawAPI)||void 0===o?void 0:o.getAppState)||void 0===l?void 0:l.call(o))||void 0===c?void 0:c.theme)||"light"===(null===(u=null===(h=null===(d=null==t?void 0:t.excalidrawData)||void 0===d?void 0:d.scene)||void 0===h?void 0:h.appState)||void 0===u?void 0:u.theme),E=()=>f?e.getCM(A):(t=>{const A=e.getCM(t),i=A.lightness;return A.lightnessTo(Math.abs(i-100))})(A),B=E().lightness,b=E().isDark(),v=app.getAccentColor(),C=()=>e.getCM(v),y=()=>e.getCM("#000000").lightnessTo(B),F="gray"===i,x=F?b?y().lighterBy(15):y().darkerBy(15):b?E().lighterBy(15).mix({color:y(),ratio:.6}):E().darkerBy(15).mix({color:y(),ratio:.6}),S=F?b?y().lighterBy(5):y().darkerBy(5):b?E().lighterBy(5).mix({color:y(),ratio:.6}):E().darkerBy(5).mix({color:y(),ratio:.6}),T=E().mix({color:b?"#f0f0f0":"#101010",ratio:.8}),I=e=>e.stringHEX({alpha:!1}),k=`--color-primary: ${I(C())};--color-primary-darker: ${I(C().darkerBy(10))};--color-primary-darkest: ${I(C().darkerBy(10))};--button-gray-1: ${I(x)};--button-gray-2: ${I(S)};--input-border-color: ${I(x)};--input-bg-color: ${I(S)};--input-label-color: ${I(T)};--island-bg-color: ${S.alphaTo(.93).stringHEX()};--popup-secondary-bg-color: ${S.alphaTo(.93).stringHEX()};--icon-fill-color: ${I(T)};--text-primary-color: ${I(T)};--overlay-bg-color: ${S.alphaTo(.6).stringHEX()};--popup-bg-color: ${I(x)};--color-gray-100: ${I(T)};--color-gray-40: ${I(T)};--color-gray-30: ${I(x)};--color-gray-80: ${I(x)};--sidebar-border-color: ${I(x)};--color-primary-light: ${I(C().lighterBy(10))};--button-hover-bg: ${I(x)};--sidebar-bg-color: ${S.alphaTo(.93).stringHEX()};--sidebar-shadow: ${I(x)};--popup-text-color: ${I(T)};--code-normal: ${I(T)};--code-background: ${I(S)};--h1-color: ${I(T)};--h2-color: ${I(T)};--h3-color: ${I(T)};--h4-color: ${I(T)};color: ${I(T)};--select-highlight-color: ${I(x)};`;null===(g=t.excalidrawContainer)||void 0===g||g.setAttribute("style",k),setTimeout((()=>t.updateScene({appState:{dynamicStyle:k}})));const U=null===(w=null===(m=null===(p=t.toolsPanelRef)||void 0===p?void 0:p.current)||void 0===m?void 0:m.containerRef)||void 0===w?void 0:w.current;if(U){let e=U.getAttribute("style");e=e.replace(/\-\-color\-primary.*/,""),U.setAttribute("style",e+k)}},renderWebView=(e,t,A,i)=>DEVICE.isDesktop?React__namespace.createElement("webview",{ref:e=>t.updateEmbeddableRef(A,e),className:"excalidraw__embeddable",title:"Excalidraw Embedded Content",allowFullScreen:!0,src:e,style:{overflow:"hidden",borderRadius:"var(--embeddable-radius)"}}):React__namespace.createElement("iframe",{ref:e=>t.updateEmbeddableRef(A,e),className:"excalidraw__embeddable",title:"Excalidraw Embedded Content",allowFullScreen:!0,allow:"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture",src:e,style:{overflow:"hidden",borderRadius:"var(--embeddable-radius)"}});function RenderObsidianView({element:e,linkText:t,view:A,containerRef:i,appState:n,theme:a}){var r,s,o;const{subpath:l,file:c}=processLinkText(t,A);if(!c)return null;const d=A.plugin.getPackage(A.ownerWindow).react,h=d.useRef(null),u=d.useRef(!1),g=d.useRef(!1),p=d.useCallback((e=>{g.current&&e.stopPropagation()}),[g.current]);d.useEffect((()=>{if(null==i?void 0:i.current)return KEYBOARD_EVENT_TYPES.forEach((e=>i.current.addEventListener(e,p))),i.current.addEventListener("click",m),()=>{(null==i?void 0:i.current)&&(KEYBOARD_EVENT_TYPES.forEach((e=>i.current.removeEventListener(e,p))),EXTENDED_EVENT_TYPES.forEach((e=>i.current.removeEventListener(e,p))),i.current.removeEventListener("click",m))}}),[]),d.useEffect((()=>{if(EXTENDED_EVENT_TYPES.forEach((e=>i.current.removeEventListener(e,p))),null==i?void 0:i.current)return g.current&&EXTENDED_EVENT_TYPES.forEach((e=>i.current.addEventListener(e,p))),()=>{(null==i?void 0:i.current)&&EXTENDED_EVENT_TYPES.forEach((e=>i.current.removeEventListener(e,p)))}}),[g.current,i.current]),d.useEffect((()=>{if(!(null==i?void 0:i.current))return;for(;i.current.hasChildNodes();)i.current.removeChild(i.current.lastChild);const t=A.ownerDocument,n=new obsidian_module.WorkspaceSplit(app.workspace,"vertical");return n.getRoot=()=>app.workspace[t===document?"rootSplit":"floatingSplit"],n.getContainer=()=>getContainerForDocument(t),n.containerEl.style.width="100%",n.containerEl.style.height="100%",n.containerEl.style.borderRadius="var(--embeddable-radius)",h.current={leaf:app.workspace.createLeafInParent(n,0),node:null},l&&A.canvasNodeFactory.isInitialized()?(app.workspace.activeLeaf===A.leaf&&DEVICE.isDesktop&&(A.ownerWindow.electronWindow.isAlwaysOnTop()||(A.ownerWindow.electronWindow.setAlwaysOnTop(!0),setTimeout((()=>{A.ownerWindow.electronWindow.setAlwaysOnTop(!1)}),500))),h.current.node=A.canvasNodeFactory.createFileNote(c,l,i.current,e.id)):(async()=>{var t,a;await h.current.leaf.openFile(c,l?{eState:{subpath:l},state:{mode:"preview"}}:void 0);const r=null===(t=h.current.leaf.view)||void 0===t?void 0:t.getViewType();if("canvas"===r&&(null===(a=h.current.leaf.view.canvas)||void 0===a||a.setReadonly(!0)),"markdown"===r&&A.canvasNodeFactory.isInitialized())await h.current.leaf.setViewState({state:{file:null}}),h.current.node=A.canvasNodeFactory.createFileNote(c,l,i.current,e.id);else{const e=n.containerEl.querySelector("div.workspace-leaf");e&&(e.style.borderRadius="var(--embeddable-radius)"),i.current.appendChild(n.containerEl)}patchMobileView(A)})(),()=>{}}),[t,l,i]),d.useEffect((()=>{var e;u.current&&((null===(e=h.current)||void 0===e?void 0:e.node)&&A.canvasNodeFactory.stopEditing(h.current.node),u.current=!1)}),[u.current,h]);const m=d.useCallback((t=>{var i,n,r;if(g.current&&t.stopPropagation(),g.current&&!u.current&&(null===(i=h.current)||void 0===i?void 0:i.leaf))if("markdown"===(null===(n=h.current.leaf.view)||void 0===n?void 0:n.getViewType())){const t=A.excalidrawAPI.getSceneElements().filter((t=>t.id===e.id))[0];if(!t||0!==t.angle)return void new obsidian_module.Notice("Sorry, cannot edit rotated markdown documents");const i=h.current.leaf.view.modes;if(!i)return;h.current.leaf.view.setMode(i.source),u.current=!0,patchMobileView(A)}else(null===(r=h.current)||void 0===r?void 0:r.node)&&A.canvasNodeFactory.startEditing(h.current.node,a)}),[null===(r=h.current)||void 0===r?void 0:r.leaf,e.id]);return d.useEffect((()=>{var t,a,r,s,o;if(!(null==i?void 0:i.current)||!(null==h?void 0:h.current))return;const l=g.current;if(g.current=(null===(t=n.activeEmbeddable)||void 0===t?void 0:t.element.id)===e.id&&"active"===(null===(a=n.activeEmbeddable)||void 0===a?void 0:a.state),l!==g.current)if("markdown"===(null===(s=null===(r=h.current.leaf)||void 0===r?void 0:r.view)||void 0===s?void 0:s.getViewType())){const e=h.current.leaf.view.modes;if(!e)return;if(!g.current)return h.current.leaf.view.setMode(e.preview),void(u.current=!1)}else(null===(o=h.current)||void 0===o?void 0:o.node)&&A.canvasNodeFactory.stopEditing(h.current.node)}),[i,h,g,null===(s=n.activeEmbeddable)||void 0===s?void 0:s.element,null===(o=n.activeEmbeddable)||void 0===o?void 0:o.state,e,A,t,l,c,a,u,A.canvasNodeFactory]),null}const CustomEmbeddable=({element:e,view:t,appState:A,linkText:i})=>{const n=t.plugin.getPackage(t.ownerWindow).react.useRef(null),a="dark"===t.excalidrawData.embeddableTheme?"theme-dark":"light"===t.excalidrawData.embeddableTheme?"theme-light":"auto"===t.excalidrawData.embeddableTheme?"dark"===A.theme?"theme-dark":"theme-light":isObsidianThemeDark()?"theme-dark":"theme-light";return React__namespace.createElement("div",{ref:n,style:{width:"100%",height:"100%",borderRadius:"var(--embeddable-radius)",color:"var(--text-normal)"},className:a},React__namespace.createElement(RenderObsidianView,{element:e,linkText:i,view:t,containerRef:n,appState:A,theme:a}))},DB_NAME="Excalidraw "+app.appId,CACHE_STORE="imageCache",BACKUP_STORE="drawingBAK",getKey=e=>`${e.filepath}#${e.blockref}#${e.sectionref}#${e.isDark?1:0}#${e.isSVG?1:0}#${e.scale}`;class ImageCache{constructor(e,t,A){this.initializationNotice=!1,this.obsidanURLCache=new Map,this.dbName=e,this.cacheStoreName=t,this.backupStoreName=A,this.db=null,this.isInitializing=!1,this.plugin=null,app.workspace.onLayoutReady((()=>this.initializeDB()))}async initializeDB(){if(!this.isInitializing&&null===this.db){this.isInitializing=!0;try{const e=indexedDB.open(this.dbName);if(e.onupgradeneeded=e=>{const t=e.target.result;t.objectStoreNames.contains(this.cacheStoreName)||t.createObjectStore(this.cacheStoreName),t.objectStoreNames.contains(this.backupStoreName)||t.createObjectStore(this.backupStoreName)},this.db=await new Promise(((t,A)=>{e.onsuccess=e=>{const A=e.target.result;t(A)},e.onerror=()=>{A(new Error(`Failed to open or create IndexedDB database: ${this.dbName}`))}})),!this.db.objectStoreNames.contains(this.cacheStoreName)||!this.db.objectStoreNames.contains(this.backupStoreName)){const e=this.db.version+1;this.db.close();const t=indexedDB.open(this.dbName,e);t.onupgradeneeded=e=>{const t=e.target.result;t.objectStoreNames.contains(this.cacheStoreName)||t.createObjectStore(this.cacheStoreName),t.objectStoreNames.contains(this.backupStoreName)||t.createObjectStore(this.backupStoreName)},await new Promise(((e,A)=>{t.onsuccess=()=>{t.result.close(),e()},t.onerror=()=>{A(new Error(`Failed to upgrade IndexedDB database: ${this.dbName}`))}})),this.db=await new Promise(((e,t)=>{const A=indexedDB.open(this.dbName);A.onsuccess=()=>{const t=A.result;e(t)},A.onerror=()=>{t(new Error(`Failed to open IndexedDB database: ${this.dbName}`))}}))}await this.purgeInvalidCacheFiles(),await this.purgeInvalidBackupFiles()}finally{this.isInitializing=!1,this.initializationNotice&&(new obsidian_module.Notice("Excalidraw Image Cache is Initialized - You may now retry opening your damaged drawing."),this.initializationNotice=!1),console.log("Initialized Excalidraw Image Cache")}}}async purgeInvalidCacheFiles(){const e=this.db.transaction(this.cacheStoreName,"readwrite").objectStore(this.cacheStoreName),t=app.vault.getFiles(),A=[],i=e.openCursor();return new Promise(((n,a)=>{i.onsuccess=i=>{const r=i.target.result;if(r){const i=r.key,n=i.split("#")[0],a=t.some((e=>e.path===n)),s=a?t.find((e=>e.path===n)):null;(!s||s&&s.stat.mtime>r.value.mtime||!r.value.blob)&&A.push(new Promise(((t,A)=>{const n=e.delete(r.primaryKey);n.onsuccess=()=>t(),n.onerror=()=>A(new Error(`Failed to delete file with key: ${i}`))}))),r.continue()}else Promise.all(A).then((()=>n())).catch((e=>a(e)))},i.onerror=()=>{a(new Error("Failed to purge invalid files from IndexedDB."))}}))}async purgeInvalidBackupFiles(){const e=this.db.transaction(this.backupStoreName,"readwrite").objectStore(this.backupStoreName),t=app.vault.getFiles(),A=[],i=e.openCursor();return new Promise(((n,a)=>{i.onsuccess=i=>{const r=i.target.result;if(r){const i=r.key,n=t.some((e=>e.path===i));n||A.push(new Promise(((t,A)=>{const n=e.delete(r.primaryKey);n.onsuccess=()=>t(),n.onerror=()=>A(new Error(`Failed to delete backup file with key: ${i}`))}))),r.continue()}else Promise.all(A).then((()=>n())).catch((e=>a(e)))},i.onerror=()=>{a(new Error("Failed to purge invalid backup files from IndexedDB."))}}))}async getObjectStore(e,t){return this.db.transaction(t,e).objectStore(t)}async getCacheData(e){const t=(await this.getObjectStore("readonly",this.cacheStoreName)).get(e);return new Promise(((e,A)=>{t.onsuccess=()=>{const A=t.result;e(A||null)},t.onerror=()=>{A(new Error("Failed to retrieve data from IndexedDB."))}}))}async getBackupData(e){const t=(await this.getObjectStore("readonly",this.backupStoreName)).get(e);return new Promise(((e,A)=>{t.onsuccess=()=>{const A=t.result;e(A||null)},t.onerror=()=>{A(new Error("Failed to retrieve backup data from IndexedDB."))}}))}isReady(){return!!this.db&&!this.isInitializing&&!!this.plugin&&this.plugin.settings.allowImageCache}async getImageFromCache(e){if(!this.isReady())return null;const t=getKey(e),A=await this.getCacheData(t),i=app.vault.getAbstractFileByPath(e.filepath.split("#")[0]);if(i&&i instanceof obsidian_module.TFile&&A&&A.mtime===i.stat.mtime){if(this.obsidanURLCache.has(t))return this.obsidanURLCache.get(t);const e=URL.createObjectURL(A.blob);return this.obsidanURLCache.set(t,e),e}}async getBAKFromCache(e){return this.isReady()?this.getBackupData(e):null}addImageToCache(e,t,A){if(!this.isReady())return;const i=app.vault.getAbstractFileByPath(e.filepath.split("#")[0]);if(!(i&&i instanceof obsidian_module.TFile))return;const n={mtime:i.stat.mtime,blob:A},a=this.db.transaction(this.cacheStoreName,"readwrite").objectStore(this.cacheStoreName),r=getKey(e);a.put(n,r),this.obsidanURLCache.set(r,t)}async addBAKToCache(e,t){this.isReady()&&this.db.transaction(this.backupStoreName,"readwrite").objectStore(this.backupStoreName).put(t,e)}async clearImageCache(){if(this.isReady())return this.clear(this.cacheStoreName,"Image cache was cleared")}async clearBackupCache(){if(this.isReady())return this.clear(this.backupStoreName,"All backups were cleared")}async clear(e,t){if(!this.isReady())return;const A=this.db.transaction([e],"readwrite").objectStore(e);return new Promise(((i,n)=>{const a=A.clear();a.onsuccess=()=>{new obsidian_module.Notice(t),i()},a.onerror=()=>n(new Error(`Failed to clear ${e}.`))}))}}const imageCache=new ImageCache(DB_NAME,CACHE_STORE,"drawingBAK");class CanvasNodeFactory{constructor(e){this.view=e,this.nodes=new Map,this.initialized=!1,this.isInitialized=()=>this.initialized}async initialize(){const e=app.internalPlugins.plugins.canvas;e._loaded||await e.load();const t=this.view.ownerDocument,A=new obsidian_module.WorkspaceSplit(app.workspace,"vertical");A.getRoot=()=>app.workspace[t===document?"rootSplit":"floatingSplit"],A.getContainer=()=>getContainerForDocument(t),this.leaf=app.workspace.createLeafInParent(A,0),this.canvas=e.views.canvas(this.leaf).canvas,this.initialized=!0}createFileNote(e,t,A,i){if(!this.initialized)return;t=null!=t?t:"",this.nodes.has(i)&&(this.canvas.removeNode(this.nodes.get(i)),this.nodes.delete(i));const n=this.canvas.createFileNode({pos:{x:0,y:0},file:e,subpath:t,save:!1});return n.setFilePath(e.path,t),n.render(),A.style.background="var(--background-primary)",A.appendChild(n.contentEl),this.nodes.set(i,n),n}startEditing(e,t){if(!this.initialized||!e)return;e.startEditing();const A=isObsidianThemeDark()?"theme-dark":"theme-light";A!==t&&(async()=>{var i,n,a,r,s,o;let l=0;for(;!(null===(a=null===(n=null===(i=e.child.editor)||void 0===i?void 0:i.containerEl)||void 0===n?void 0:n.parentElement)||void 0===a?void 0:a.parentElement)&&l++<100;)await sleep(25);(null===(o=null===(s=null===(r=e.child.editor)||void 0===r?void 0:r.containerEl)||void 0===s?void 0:s.parentElement)||void 0===o?void 0:o.parentElement)&&(e.child.editor.containerEl.parentElement.parentElement.classList.remove(A),e.child.editor.containerEl.parentElement.parentElement.classList.add(t),new MutationObserver((e=>{for(const i of e)if("attributes"===i.type&&"class"===i.attributeName){const e=i.target;e.classList.contains(A)&&(e.classList.remove(A),e.classList.add(t))}})).observe(e.child.editor.containerEl.parentElement.parentElement,{attributes:!0}))})()}stopEditing(e){this.initialized&&e&&e.child.editMode&&e.child.showPreview()}purgeNodes(){this.initialized&&(this.nodes.forEach((e=>{this.canvas.removeNode(e)})),this.nodes.clear())}}class EmbeddableMenu{constructor(e,t){this.view=e,this.containerRef=t,this.updateElement=(e,t,A)=>{if(!t)return;const i=this.view,n=`[[${app.metadataCache.fileToLinktext(A,i.file.path,"md"===A.extension)}${e}]]`;mutateElement(t,{link:n}),i.excalidrawData.elementLinks.set(t.id,n),i.setDirty(99),i.updateScene({appState:{activeEmbeddable:null}})},this.menuFadeTimeout=0,this.menuElementId=null}handleMouseEnter(){var e;clearTimeout(this.menuFadeTimeout),null===(e=this.containerRef.current)||void 0===e||e.style.setProperty("opacity","1")}handleMouseLeave(){const e=this;this.menuFadeTimeout=window.setTimeout((()=>{var t;null===(t=e.containerRef.current)||void 0===t||t.style.setProperty("opacity","0.2")}),5e3)}renderButtons(e){var t,A;const i=this.view,n=null==i?void 0:i.excalidrawAPI;if(!n)return null;if(!e.activeEmbeddable||"active"!==e.activeEmbeddable.state||e.viewModeEnabled)return this.menuElementId=null,this.menuFadeTimeout&&(clearTimeout(this.menuFadeTimeout),this.menuFadeTimeout=0),null;const a=null===(t=e.activeEmbeddable)||void 0===t?void 0:t.element;this.menuElementId!==a.id&&(this.menuElementId=a.id,this.handleMouseLeave());let r=a.link;if(!r)return null;const s=useDefaultExcalidrawFrame(a);let o=null===(A=a.link)||void 0===A?void 0:A.match(REG_LINKINDEX_HYPERLINK);if(!s&&!o){const t=REGEX_LINK.getRes(a.link).next();if(!t||!t.value&&t.done)return null;if(r=REGEX_LINK.getLink(t),o=r.match(REG_LINKINDEX_HYPERLINK),!o){const{subpath:t,file:A}=processLinkText(r,i);if(!A||"md"!==A.extension)return null;const{x:s,y:o}=sceneCoordsToViewportCoords({sceneX:a.x,sceneY:a.y},e),l=o-2.5*ROOTELEMENTSIZE-e.offsetTop+"px",c=s-e.offsetLeft+"px";return React__namespace.createElement("div",{ref:this.containerRef,className:"embeddable-menu",style:{top:l,left:c,opacity:1},onMouseEnter:()=>this.handleMouseEnter(),onPointerDown:()=>this.handleMouseEnter(),onMouseLeave:()=>this.handleMouseLeave()},React__namespace.createElement("div",{className:"Island",style:{position:"relative"}},React__namespace.createElement(ActionButton,{key:"MarkdownSection",title:t$d("NARROW_TO_HEADING"),action:async()=>{const e=(await app.metadataCache.blockCache.getForFile({isCancelled:()=>!1},A)).blocks.filter((e=>{var t;return e.display&&"heading"===(null===(t=e.node)||void 0===t?void 0:t.type)})),i=[""].concat(e.map((e=>`#${e.display.replaceAll(REG_BLOCK_REF_CLEAN,"").trim()}`))),n=[t$d("SHOW_ENTIRE_FILE")].concat(e.map((e=>e.display))),r=await ScriptEngine.suggester(app,n,i,"Select section from document");(r||""===r)&&r!==t&&this.updateElement(r,a,A)},icon:ICONS.ZoomToSection,view:i}),React__namespace.createElement(ActionButton,{key:"MarkdownBlock",title:t$d("NARROW_TO_BLOCK"),action:async()=>{var e,i,n;if(!A)return;const r=(await app.metadataCache.blockCache.getForFile({isCancelled:()=>!1},A)).blocks.filter((e=>{var t;return e.display&&"paragraph"===(null===(t=e.node)||void 0===t?void 0:t.type)})),s=["entire-file"].concat(r),o=[t$d("SHOW_ENTIRE_FILE")].concat(r.map((e=>{var t;return`${(null===(t=e.node)||void 0===t?void 0:t.id)?`#^${e.node.id}: `:""}${e.display.trim()}`}))),l=await ScriptEngine.suggester(app,o,s,"Select section from document");if(!l)return;if("entire-file"===l){if(""===t)return;return void this.updateElement("",a,A)}let c=l.node.id;if(!c||`#^${c}`!==t){if(!c){const t=null===(n=null===(i=null===(e=l.node)||void 0===e?void 0:e.position)||void 0===i?void 0:i.end)||void 0===n?void 0:n.offset;if(!t)return;c=nanoid();const a=await app.vault.cachedRead(A);if(!a)return;await app.vault.modify(A,a.slice(0,t)+` ^${c}`+a.slice(t)),await sleep(200)}this.updateElement(`#^${c}`,a,A)}},icon:ICONS.ZoomToBlock,view:i}),React__namespace.createElement(ActionButton,{key:"ZoomToElement",title:t$d("ZOOM_TO_FIT"),action:()=>{a&&n.zoomToFit([a],i.plugin.settings.zoomToFitMaxLevel,.1)},icon:ICONS.ZoomToSelectedElement,view:i})))}}if(o||s){const t=s?n.getHTMLIFrameElement(a.id):i.getEmbeddableElementById(a.id);if(!t||!t.contentWindow)return null;const{x:A,y:o}=sceneCoordsToViewportCoords({sceneX:a.x,sceneY:a.y},e),l=o-2.5*ROOTELEMENTSIZE-e.offsetTop+"px",c=A-e.offsetLeft+"px";return React__namespace.createElement("div",{ref:this.containerRef,className:"embeddable-menu",style:{top:l,left:c,opacity:1},onMouseEnter:()=>this.handleMouseEnter(),onPointerDown:()=>this.handleMouseEnter(),onMouseLeave:()=>this.handleMouseLeave()},React__namespace.createElement("div",{className:"Island",style:{position:"relative"}},t.src!==r&&!t.src.startsWith("https://www.youtube.com")&&!t.src.startsWith("https://player.vimeo.com")&&React__namespace.createElement(ActionButton,{key:"Reload",title:t$d("RELOAD"),action:()=>{t.src=r},icon:ICONS.Reload,view:i}),React__namespace.createElement(ActionButton,{key:"Open",title:t$d("OPEN_IN_BROWSER"),action:()=>{i.openExternalLink(t.src)},icon:ICONS.Globe,view:i}),React__namespace.createElement(ActionButton,{key:"ZoomToElement",title:t$d("ZOOM_TO_FIT"),action:()=>{a&&n.zoomToFit([a],i.plugin.settings.zoomToFitMaxLevel,.1)},icon:ICONS.ZoomToSelectedElement,view:i})))}}}var TextMode;!function(e){e.parsed="parsed",e.raw="raw"}(TextMode||(TextMode={}));const HIDE="excalidraw-hidden",SHOW="excalidraw-visible",addFiles=async(e,t,A)=>{if(!e||0===e.length||!t)return;const i=t.excalidrawAPI;if(!i)return;if(e=e.filter((e=>e&&e.size&&e.size.height>0&&e.size.width>0)),0===e.length)return;const n=scaleLoadedImage(t.getScene(),e);void 0===A&&(A=n.scene.appState.theme),n.dirty&&t.updateScene({elements:n.scene.elements,appState:n.scene.appState,commitToHistory:!1});for(const i of e)if(t.excalidrawData.hasFile(i.id)&&t.excalidrawData.getFile(i.id).setImage(i.dataURL,i.mimeType,i.size,A,i.hasSVGwithBitmap),t.excalidrawData.hasEquation(i.id)){const e=t.excalidrawData.getEquation(i.id).latex;t.excalidrawData.setEquation(i.id,{latex:e,isLoaded:!0})}i.addFiles(e)},warningUnknowSeriousError=()=>{new obsidian_module.Notice("WARNING: Excalidraw ran into an unknown problem!\n\nThere is a risk that your most recent changes cannot be saved.\n\nTo be on the safe side...\n1) Please select your drawing using CTRL/CMD+A and make a copy with CTRL/CMD+C.\n2) Then create an empty drawing in a new pane by CTRL/CMD+clicking the Excalidraw ribbon button,\n3) and paste your work to the new document with CTRL/CMD+V.",6e4)};class ExcalidrawView extends obsidian_module.TextFileView{constructor(e,t){super(e),this.getScene=null,this.addElements=null,this.getSelectedTextElement=null,this.getSelectedImageElement=null,this.getSelectedElementWithLink=null,this.addText=null,this.refresh=null,this.excalidrawRef=null,this.excalidrawAPI=null,this.excalidrawWrapperRef=null,this.toolsPanelRef=null,this.embeddableMenuRef=null,this.linksAlwaysOpenInANewPane=!1,this.lastSaveTimestamp=0,this.lastLoadedFile=null,this.modifierKeyDown={shiftKey:!1,metaKey:!1,ctrlKey:!1,altKey:!1},this.currentPosition={x:0,y:0},this.embeddableRefs=new Map,this.semaphores={popoutUnload:!1,viewunload:!1,scriptsReady:!1,justLoaded:!1,preventAutozoom:!1,autosaving:!1,dirty:null,preventReload:!1,isEditingText:!1,saving:!1,forceSaving:!1,hoverSleep:!1,wheelTimeout:null},this.autosaveTimer=null,this.textMode=TextMode.raw,this.compatibilityMode=!1,this.isEditingTextResetTimer=null,this.id=this.leaf.id,this.getHookServer=()=>{var e;return null!==(e=this.hookServer)&&void 0!==e?e:this.plugin.ea},this.preventReloadResetTimer=null,this.hiddenMobileLeaves=[],this.offsetLeft=0,this.offsetTop=0,this.blockTextModeChange=!1,this.isLoaded=!1,this.activeLoader=null,this.nextLoader=null,this.initialContainerSizeUpdate=!1,this.previousSceneVersion=0,this.previousBackgroundColor="",this.previousTheme="",this.colorChangeTimer=null,this.plugin=t,this.excalidrawData=new ExcalidrawData(t),this.hookServer=t.ea,this.canvasNodeFactory=new CanvasNodeFactory(this)}setHookServer(e){this.hookServer=e||this.plugin.ea}preventAutozoom(){this.semaphores.preventAutozoom=!0,setTimeout((()=>this.semaphores.preventAutozoom=!1),1500)}saveExcalidraw(e){if(!e){if(!this.getScene)return!1;e=this.getScene()}const t=`${this.file.path.substring(0,this.file.path.lastIndexOf(".md"))}.excalidraw`,A=app.vault.getAbstractFileByPath(obsidian_module.normalizePath(t));A&&A instanceof obsidian_module.TFile?app.vault.modify(A,JSON.stringify(e,null,"\t")):app.vault.create(t,JSON.stringify(e,null,"\t"))}async exportExcalidraw(e){this.getScene&&this.file&&(app.isMobile?new Prompt(app,"Please provide filename",this.file.basename,"filename, leave blank to cancel action").openAndGetValue((async e=>{if(!e)return;e=`${e}.excalidraw`;const t=splitFolderAndFilename(this.file.path).folderpath;await checkAndCreateFolder(t);const A=getNewUniqueFilepath(app.vault,e,t);app.vault.create(A,JSON.stringify(this.getScene(),null,"\t")),new obsidian_module.Notice(`Exported to ${A}`,6e3)})):download("data:text/plain;charset=utf-8",encodeURIComponent(JSON.stringify(this.getScene(e),null,"\t")),`${this.file.basename}.excalidraw`))}async svg(e,t,A){const i=this.exportDialog,n={withBackground:i?!i.transparent:getWithBackground(this.plugin,this.file),withTheme:!0};return await getSVG(Object.assign(Object.assign({},e),{appState:Object.assign(Object.assign({},e.appState),{theme:null!=t?t:i?i.theme:getExportTheme(this.plugin,this.file,e.appState.theme),exportEmbedScene:void 0===A?!!i&&i.embedScene:A})}),n,i?i.padding:getExportPadding(this.plugin,this.file))}async saveSVG(e,t){if(!e){if(!this.getScene)return!1;e=this.getScene()}const A=async(A,i)=>{const n=app.vault.getAbstractFileByPath(obsidian_module.normalizePath(A)),a=await this.svg(e,i,t);if(!a)return;const r=(new XMLSerializer).serializeToString(embedFontsInSVG(a,this.plugin));n&&n instanceof obsidian_module.TFile?await app.vault.modify(n,r):await app.vault.create(A,r)};this.plugin.settings.autoExportLightAndDark?(await A(getIMGFilename(this.file.path,"dark.svg"),"dark"),await A(getIMGFilename(this.file.path,"light.svg"),"light")):await A(getIMGFilename(this.file.path,"svg"))}async exportSVG(e,t){if(!this.getScene||!this.file)return;let A=await this.svg(this.getScene(t),void 0,e);A&&(A=embedFontsInSVG(A,this.plugin),download(null,svgToBase64(A.outerHTML),`${this.file.basename}.svg`))}async png(e,t,A){const i=this.exportDialog,n={withBackground:i?!i.transparent:getWithBackground(this.plugin,this.file),withTheme:!0};return await getPNG(Object.assign(Object.assign({},e),{appState:Object.assign(Object.assign({},e.appState),{theme:null!=t?t:i?i.theme:getExportTheme(this.plugin,this.file,e.appState.theme),exportEmbedScene:void 0===A?!!i&&i.embedScene:A})}),n,i?i.padding:getExportPadding(this.plugin,this.file),i?i.scale:getPNGScale(this.plugin,this.file))}async savePNG(e,t){if(!e){if(!this.getScene)return!1;e=this.getScene()}const A=async(A,i)=>{const n=app.vault.getAbstractFileByPath(obsidian_module.normalizePath(A)),a=await this.png(e,i,t);a&&(n&&n instanceof obsidian_module.TFile?await app.vault.modifyBinary(n,await a.arrayBuffer()):await app.vault.createBinary(A,await a.arrayBuffer()))};this.plugin.settings.autoExportLightAndDark?(await A(getIMGFilename(this.file.path,"dark.png"),"dark"),await A(getIMGFilename(this.file.path,"light.png"),"light")):await A(getIMGFilename(this.file.path,"png"))}async exportPNGToClipboard(e,t){if(!this.getScene||!this.file)return;const A=await this.png(this.getScene(t),void 0,e);A&&await navigator.clipboard.write([new window.ClipboardItem({"image/png":A})])}async exportPNG(e,t){if(!this.getScene||!this.file)return;const A=await this.png(this.getScene(t),void 0,e);if(!A)return;const i=new FileReader;i.readAsDataURL(A);const n=this;i.onloadend=function(){const e=i.result;download(null,e,`${n.file.basename}.png`)}}async save(e=!0,t=!1){if(!this.isLoaded)return;if(this.semaphores.saving)return;this.semaphores.saving=!0;let A=!1;if(this.getScene&&this.excalidrawAPI&&this.isLoaded&&this.file&&app.vault.getAbstractFileByPath(this.file.path)){try{const i=Boolean(null!==this.semaphores.dirty&&this.semaphores.dirty||this.semaphores.autosaving||t),n=this.getScene();if(this.compatibilityMode?await this.excalidrawData.syncElements(n):await this.excalidrawData.syncElements(n,this.excalidrawAPI.getAppState().selectedElementIds)&&!this.semaphores.popoutUnload&&await this.loadDrawing(!1,this.excalidrawAPI.getSceneElementsIncludingDeleted().filter((e=>e.isDeleted))),i){this.preventReloadResetTimer&&(clearTimeout(this.preventReloadResetTimer),this.preventReloadResetTimer=null),this.semaphores.preventReload=e,await super.save();const i=this.file.path,n=this.lastSavedData;if(setTimeout((()=>imageCache.addBAKToCache(i,n)),50),A=this.lastSaveTimestamp===this.file.stat.mtime&&!e&&t,this.lastSaveTimestamp=this.file.stat.mtime,this.clearDirty(),e){const e=this;this.preventReloadResetTimer=setTimeout((()=>e.semaphores.preventReload=!1),2e3)}}if(!A&&!this.semaphores.autosaving&&(!this.semaphores.viewunload||this.semaphores.popoutUnload)){const e=this.excalidrawData.autoexportPreference;(e===AutoexportPreference.inherit&&this.plugin.settings.autoexportSVG||e===AutoexportPreference.both||e===AutoexportPreference.svg)&&this.saveSVG(),(e===AutoexportPreference.inherit&&this.plugin.settings.autoexportPNG||e===AutoexportPreference.both||e===AutoexportPreference.png)&&this.savePNG(),!this.compatibilityMode&&this.plugin.settings.autoexportExcalidraw&&this.saveExcalidraw()}}catch(e){errorlog({where:"ExcalidrawView.save",fn:this.save,error:e}),warningUnknowSeriousError()}this.semaphores.saving=!1,A&&this.reload(!0,this.file)}else this.semaphores.saving=!1}getViewData(){var e,t,A;if(!this.getScene||!this.excalidrawData.loaded)return this.data;const i=this.getScene();if(!i)return this.data;if(!this.compatibilityMode){let i=this.data.search(/(^%%\n)?# Text Elements\n/m);if(-1==i&&(i=this.data.search(/(%%\n)?# Drawing\n/)),-1==i)return this.data;const n=(null===(e=this.exportDialog)||void 0===e?void 0:e.dirty)&&(null===(t=this.exportDialog)||void 0===t?void 0:t.saveSettings)?[["excalidraw-export-padding",this.exportDialog.padding.toString()],["excalidraw-export-pngscale",this.exportDialog.scale.toString()],["excalidraw-export-dark","dark"===this.exportDialog.theme?"true":"false"],["excalidraw-export-transparent",this.exportDialog.transparent?"true":"false"],[FRONTMATTER_KEY,this.textMode===TextMode.raw?"raw":"parsed"]]:[[FRONTMATTER_KEY,this.textMode===TextMode.raw?"raw":"parsed"]];(null===(A=this.exportDialog)||void 0===A?void 0:A.dirty)&&(this.exportDialog.dirty=!1);let a=updateFrontmatterInString(this.data.substring(0,i),n);const r=/(^---[\w\W]*?---\n)(!\[\[.*?]]\n(%%\n)?)/m;a.match(r)&&(a=a.replace(r,"$1")),this.excalidrawData.disableCompression||(this.excalidrawData.disableCompression=this.isEditedAsMarkdownInOtherView());const s=a+this.excalidrawData.generateMD(this.excalidrawAPI.getSceneElementsIncludingDeleted().filter((e=>e.isDeleted)));return this.excalidrawData.disableCompression=!1,s}return this.compatibilityMode?JSON.stringify(i,null,"\t"):this.data}restoreMobileLeaves(){this.hiddenMobileLeaves.length>0&&(this.hiddenMobileLeaves.forEach((e=>{e[0].containerEl.style.display=e[1]})),this.hiddenMobileLeaves=[])}toggleDisableBinding(){const e=!this.excalidrawAPI.getAppState().invertBindingBehaviour;this.updateScene({appState:{invertBindingBehaviour:e}}),new obsidian_module.Notice(e?"Inverted Mode: Default arrow binding is now disabled. Use CTRL/CMD to temporarily enable binding when needed.":"Normal Mode: Arrow binding is now enabled. Use CTRL/CMD to temporarily disable binding when needed.")}gotoFullscreen(){this.plugin.leafChangeTimeout&&(clearTimeout(this.plugin.leafChangeTimeout),this.plugin.leafChangeTimeout=null),this.excalidrawWrapperRef&&(this.toolsPanelRef&&this.toolsPanelRef.current&&this.toolsPanelRef.current.setFullscreen(!0),(e=>{for(;e&&!e.hasClass("workspace-split");)e.addClass(SHOW),e=e.parentElement;e&&(e.addClass(SHOW),e.querySelectorAll(`div.workspace-split:not(.${SHOW})`).forEach((e=>e.addClass(SHOW))),e.querySelector(`div.workspace-leaf-content.${SHOW} > .view-header`).addClass(SHOW),e.querySelectorAll(`div.workspace-tab-container.${SHOW} > div.workspace-leaf:not(.${SHOW})`).forEach((e=>e.addClass(SHOW))),e.querySelectorAll(`div.workspace-tabs.${SHOW} > div.workspace-tab-header-container`).forEach((e=>e.addClass(SHOW))),e.querySelectorAll(`div.workspace-split.${SHOW} > div.workspace-tabs:not(.${SHOW})`).forEach((e=>e.addClass(SHOW))));const t=this.ownerDocument;t.body.querySelectorAll(`div.workspace-split:not(.${SHOW})`).forEach((e=>e.addClass(HIDE))),t.body.querySelector(`div.workspace-leaf-content.${SHOW} > .view-header`).addClass(HIDE),t.body.querySelectorAll(`div.workspace-tab-container.${SHOW} > div.workspace-leaf:not(.${SHOW})`).forEach((e=>e.addClass(HIDE))),t.body.querySelectorAll(`div.workspace-tabs.${SHOW} > div.workspace-tab-header-container`).forEach((e=>e.addClass(HIDE))),t.body.querySelectorAll(`div.workspace-split.${SHOW} > div.workspace-tabs:not(.${SHOW})`).forEach((e=>e.addClass(HIDE))),t.body.querySelectorAll("div.workspace-ribbon").forEach((e=>e.addClass(HIDE))),t.body.querySelectorAll("div.mobile-navbar").forEach((e=>e.addClass(HIDE))),t.body.querySelectorAll("div.status-bar").forEach((e=>e.addClass(HIDE)))})(this.contentEl))}isFullscreen(){return Boolean(document.body.querySelector(".excalidraw-hidden"))}exitFullscreen(){this.toolsPanelRef&&this.toolsPanelRef.current&&this.toolsPanelRef.current.setFullscreen(!1);const e=this.ownerDocument;e.querySelectorAll(".excalidraw-hidden").forEach((e=>e.removeClass(HIDE))),e.querySelectorAll(".excalidraw-visible").forEach((e=>e.removeClass(SHOW)))}removeLinkTooltip(){const e=this.ownerDocument.body.querySelector("body>div.excalidraw-tooltip,div.excalidraw-tooltip--visible");e&&e.classList.remove("excalidraw-tooltip--visible")}handleLinkHookCall(e,t,A){if(this.getHookServer().onLinkClickHook)try{if(!this.getHookServer().onLinkClickHook(e,t,A,this,this.getHookServer()))return!0}catch(e){errorlog({where:"ExcalidrawView.onLinkOpen",fn:this.getHookServer().onLinkClickHook,error:e})}return!1}openExternalLink(e,t){return!!e.match(REG_LINKINDEX_HYPERLINK)&&(window.open(e,"_blank"),!0)}openTagSearch(e){const t=e.matchAll(/#([\p{Letter}\p{Emoji_Presentation}\p{Number}\/_-]+)/gu).next();if(!t.value||t.value.length<2)return;const A=app.workspace.getLeavesOfType("search");0!=A.length&&(A[0].view.setQuery(`tag:${t.value[1]}`),app.workspace.revealLeaf(A[0]),this.isFullscreen()&&this.exitFullscreen())}async linkClick(e,t,A,i,n){var a,r,s,o,l;t||(t={id:null,text:null}),A||(A={id:null,fileId:null}),i||(i={id:null,text:null}),n||(n={shiftKey:e.shiftKey,ctrlKey:e.ctrlKey,metaKey:e.metaKey,altKey:e.altKey});const c=linkClickModifierType(n);let d=null,h=null,u=null;if((null==t?void 0:t.id)||(null==i?void 0:i.id)){if(u=null!==(a=null==i?void 0:i.text)&&void 0!==a?a:this.textMode===TextMode.parsed?this.excalidrawData.getRawText(t.id):t.text,!u)return;u=u.replaceAll("\n","");const A=null!==(r=t.id)&&void 0!==r?r:i.id,n=this.excalidrawAPI.getSceneElements().filter((e=>e.id===A))[0];if(this.handleLinkHookCall(n,u,e))return;if(this.openExternalLink(u))return;const s=REGEX_LINK.getResList(u);let o=s[0];if(s.length>1&&(o=await ScriptEngine.suggester(app,s.filter((e=>Boolean(e.value))).map((e=>REGEX_LINK.getLink(e))),s.filter((e=>Boolean(e.value))),"Select link to open"),!o))return;if(!(null==o?void 0:o.value))return void this.openTagSearch(u);if(u=REGEX_LINK.getLink(o),this.openExternalLink(u))return;if(u.search("#")>-1){const e=getLinkParts(u,this.file);h=`#${e.isBlockRef?"^":""}${e.ref}`,u=e.path}if(u.match(REG_LINKINDEX_INVALIDCHARS))return void new obsidian_module.Notice(t$d("FILENAME_INVALID_CHARS"),4e3);d=this.app.metadataCache.getFirstLinkpathDest(u,this.file.path)}if(null==A?void 0:A.id){if(this.excalidrawData.hasEquation(A.fileId)){const e=this.excalidrawData.getEquation(A.fileId).latex;return void new Prompt(app,t$d("ENTER_LATEX"),e,"").openAndGetValue((async t=>{t&&t!==e&&(this.excalidrawData.setEquation(A.fileId,{latex:t,isLoaded:!1}),await this.save(!1),await updateEquation(t,A.fileId,this,addFiles,this.plugin),this.setDirty(1))}))}if(await this.save(!1),this.excalidrawData.hasFile(A.fileId)){const e=this.excalidrawData.getFile(A.fileId);if(e.isHyperlink)return void window.open(e.hyperlink,"_blank");if("md-properties"===c&&"md"===e.file.extension&&!this.plugin.isExcalidrawFile(e.file)){const t=async t=>{t&&e.linkParts.original!==t&&(e.resetImage(this.file.path,t),this.setDirty(2),await this.save(!1),await this.loadSceneFiles())};return void GenericInputPrompt.Prompt(this,this.plugin,app,"Customize the link",void 0,e.linkParts.original,[{caption:"✅",action:t}],1,!1,(e=>e.createEl("p",{text:fragWithHTML("Do not add [[square brackets]] around the filename!
Follow this format when editing your link:
filename#^blockref|WIDTHxMAXHEIGHT")})),!1).then(t,(()=>{}))}u=e.file.path,d=e.file,"pdf"===d.extension.toLowerCase()&&(h=null===(s=e.linkParts.original.match(/(#.*)$/))||void 0===s?void 0:s[1])}}if(!u)return void new obsidian_module.Notice(t$d("LINK_BUTTON_CLICK_NO_TEXT"),2e4);const g=null!==(l=null!==(o=A.id)&&void 0!==o?o:t.id)&&void 0!==l?l:i.id,p=this.excalidrawAPI.getSceneElements().filter((e=>e.id===g))[0];if(!this.handleLinkHookCall(p,u,e))try{if("active-pane"!==c&&this.isFullscreen()&&this.exitFullscreen(),!d)return void new NewFileActions(this.plugin,u,n,this).open();this.linksAlwaysOpenInANewPane&&!anyModifierKeysPressed(n)&&(n=emulateKeysForLinkClick("new-pane"));const e=getLeaf(this.plugin,this.leaf,n);try{const t=app.plugins.plugins["drawio-obsidian"];if(t&&t._loaded&&"svg"===d.extension){const t=await this.app.vault.cachedRead(d);if(/(<|\<)(mxfile|mxgraph)/i.test(t))return void e.setViewState({type:"diagram-edit",state:{file:d.path}})}}catch(e){console.error(e)}await e.openFile(d,h?{active:!this.linksAlwaysOpenInANewPane,eState:{subpath:h}}:void 0)}catch(e){new obsidian_module.Notice(e,4e3)}}async handleLinkClick(e){this.removeLinkTooltip();const t=this.getSelectedTextElement(),A=(null==t?void 0:t.id)?null:this.getSelectedImageElement(),i=(null==A?void 0:A.id)||(null==t?void 0:t.id)?null:this.getSelectedElementWithLink();this.linkClick(e,t,A,i)}onResize(){var e,t;if(this.plugin.leafChangeTimeout)return;const A=this.excalidrawAPI;this.plugin.settings.zoomToFitOnResize&&this.excalidrawRef&&!this.semaphores.isEditingText&&A&&"text"!==(null===(t=null===(e=A.getAppState())||void 0===e?void 0:e.editingElement)||void 0===t?void 0:t.type)&&this.zoomToFit(!1)}getSceneVersion(e){return this.excalidrawGetSceneVersion||(this.excalidrawGetSceneVersion=this.plugin.getPackage(this.ownerWindow).excalidrawLib.getSceneVersion),this.excalidrawGetSceneVersion(e.filter((e=>!e.isDeleted)))}async forceSave(e=!1){this.semaphores.autosaving||this.semaphores.saving?e||new obsidian_module.Notice("Force Save aborted because saving is in progress)"):(this.preventReloadResetTimer&&(clearTimeout(this.preventReloadResetTimer),this.preventReloadResetTimer=null),this.semaphores.preventReload=!1,this.semaphores.forceSaving=!0,await this.save(!1,!0),this.plugin.triggerEmbedUpdates(),this.loadSceneFiles(),this.semaphores.forceSaving=!1,e||new obsidian_module.Notice("Save successful",1e3))}onload(){const e=Boolean(void 0===this.containerEl.onWindowMigrated);app.isMobile||e||this.containerEl.onWindowMigrated((()=>this.leaf.rebuildView()));const t=app.isMobile?document:this.containerEl.ownerDocument;this.ownerDocument=t,this.ownerWindow=this.ownerDocument.defaultView,this.plugin.getPackage(this.ownerWindow),this.semaphores.scriptsReady=!0,this.wheelEvent=e=>{this.semaphores.wheelTimeout&&clearTimeout(this.semaphores.wheelTimeout),this.semaphores.hoverSleep&&this.clearHoverPreview&&this.clearHoverPreview(),this.semaphores.wheelTimeout=setTimeout((()=>{clearTimeout(this.semaphores.wheelTimeout),this.semaphores.wheelTimeout=null}),1e3)},this.containerEl.addEventListener("wheel",this.wheelEvent,{passive:!1}),this.addAction("ScriptEngine",t$d("INSTALL_SCRIPT_BUTTON"),(()=>{new ScriptInstallPrompt(this.plugin).open()})),this.diskIcon=this.addAction("save",t$d("FORCE_SAVE"),(async()=>this.forceSave())),this.textIsRaw_Element=this.addAction("presentation",t$d("RAW"),(()=>this.changeTextMode(TextMode.parsed))),this.textIsParsed_Element=this.addAction("quote-glyph",t$d("PARSED"),(()=>this.changeTextMode(TextMode.raw))),this.linkAction_Element=this.addAction("link",t$d("OPEN_LINK"),(e=>this.handleLinkClick(e))),app.isMobile||this.addAction("fullscreen","Use the action on the Excalidraw Obsidian Panel or the Command Palette to exit fullscreen mode. You can set up a hotkey for toggling fullscreen mode in Obsidian settings under Hotkeys.",(()=>this.gotoFullscreen()));const A=this;app.workspace.onLayoutReady((async()=>{this.canvasNodeFactory.initialize(),A.contentEl.addClass("excalidraw-view"),await A.addSlidingPanesListner(),A.addParentMoveObserver(),A.onKeyUp=e=>{A.modifierKeyDown={shiftKey:e.shiftKey,ctrlKey:e.ctrlKey,altKey:e.altKey,metaKey:e.metaKey}},A.onKeyDown=e=>{this.modifierKeyDown={shiftKey:e.shiftKey,ctrlKey:e.ctrlKey,altKey:e.altKey,metaKey:e.metaKey}},A.ownerWindow.addEventListener("keydown",A.onKeyDown,!1),A.ownerWindow.addEventListener("keyup",A.onKeyUp,!1)})),this.setupAutosaveTimer(),super.onload()}async addSlidingPanesListner(){const e=this;this.slidingPanesListner=()=>{e.refresh&&e.refresh()};let t=app.workspace.rootSplit;for(;!t;)await sleep(50),t=app.workspace.rootSplit;t.containerEl.addEventListener("scroll",this.slidingPanesListner)}removeSlidingPanesListner(){var e;this.slidingPanesListner&&(null===(e=app.workspace.rootSplit.containerEl)||void 0===e||e.removeEventListener("scroll",this.slidingPanesListner))}addParentMoveObserver(){var e;const t=null!==(e=getParentOfClass(this.containerEl,"popover"))&&void 0!==e?e:getParentOfClass(this.containerEl,"workspace-leaf");if(!t)return;const A=t.classList.contains("popover");this.offsetLeft=t.offsetLeft,this.offsetTop=t.offsetTop;const i=this;this.parentMoveObserver=new MutationObserver((async e=>{const t=e[0].target;if(!(t instanceof HTMLElement))return;const{offsetLeft:A,offsetTop:n}=t;A===i.offsetLeft&&n==i.offsetTop||(i.refresh&&i.refresh(),i.offsetLeft=A,i.offsetTop=n)})),this.parentMoveObserver.observe(t,{attributeOldValue:!0,attributeFilter:A?["data-x","data-y"]:["class","style"]})}removeParentMoveObserver(){this.parentMoveObserver&&this.parentMoveObserver.disconnect()}setTheme(e){const t=this.excalidrawAPI;if(!this.excalidrawRef||!t)return;if(this.file&&hasExportTheme(this.plugin,this.file))return;const A=t.getAppState();this.excalidrawData.scene.theme=e,this.updateScene({appState:Object.assign(Object.assign({},A),{theme:e}),commitToHistory:!1})}async changeTextMode(e,t=!0){if(this.compatibilityMode)return;if(this.blockTextModeChange)return;this.blockTextModeChange=!0,this.textMode=e,e===TextMode.parsed?(this.textIsRaw_Element.hide(),this.textIsParsed_Element.show()):(this.textIsRaw_Element.show(),this.textIsParsed_Element.hide()),this.toolsPanelRef&&this.toolsPanelRef.current&&this.toolsPanelRef.current.setPreviewMode(e===TextMode.parsed);const A=this.excalidrawAPI;A&&t&&(await this.save(),this.preventAutozoom(),await this.excalidrawData.loadData(this.data,this.file,this.textMode),this.excalidrawData.scene.appState.theme=A.getAppState().theme,await this.loadDrawing(!1),A.history.clear()),this.prevTextMode=this.textMode,this.blockTextModeChange=!1}setupAutosaveTimer(){const e=async()=>{var t;if(!this.isLoaded)return void(this.autosaveTimer=setTimeout(e,this.plugin.settings.autosaveInterval));const A=this.excalidrawAPI;if(!A)return void warningUnknowSeriousError();const i=A.getAppState(),n=null!==i.editingElement;if(this.refresh(),!this.semaphores.dirty||this.semaphores.dirty!=(null===(t=this.file)||void 0===t?void 0:t.path)||!this.plugin.settings.autosave||this.semaphores.forceSaving||this.semaphores.autosaving||n||null!==i.draggingElement)this.autosaveTimer=setTimeout(e,this.plugin.activeExcalidrawView===this&&this.semaphores.dirty&&this.plugin.settings.autosave?1e3:this.plugin.settings.autosaveInterval);else{if(this.autosaveTimer=null,this.excalidrawRef){this.semaphores.autosaving=!0;const e=this;this.save().then((()=>e.semaphores.autosaving=!1))}this.autosaveTimer=setTimeout(e,this.plugin.settings.autosaveInterval)}};this.autosaveFunction=e,this.autosaveTimer&&(clearTimeout(this.autosaveTimer),this.autosaveTimer=null),this.autosaveTimer=setTimeout(e,this.plugin.settings.autosaveInterval)}onunload(){var e,t,A,i,n,a;if(this.restoreMobileLeaves(),this.semaphores.viewunload=!0,this.semaphores.popoutUnload=this.ownerDocument!==document&&0===this.ownerDocument.body.querySelectorAll(".workspace-tab-header").length,null===(e=this.ownerWindow)||void 0===e||e.removeEventListener("keydown",this.onKeyDown,!1),null===(t=this.ownerWindow)||void 0===t||t.removeEventListener("keyup",this.onKeyUp,!1),this.containerEl.removeEventListener("wheel",this.wheelEvent,!1),this.getHookServer().onViewUnloadHook)try{this.getHookServer().onViewUnloadHook(this)}catch(e){errorlog({where:"ExcalidrawView.onunload",fn:this.getHookServer().onViewUnloadHook,error:e})}const r=null===(i=null===(A=this.containerEl)||void 0===A?void 0:A.ownerDocument)||void 0===i?void 0:i.body.querySelector("body>div.excalidraw-tooltip,div.excalidraw-tooltip--visible");r&&(null===(a=null===(n=this.containerEl)||void 0===n?void 0:n.ownerDocument)||void 0===a||a.body.removeChild(r)),this.removeParentMoveObserver(),this.removeSlidingPanesListner(),this.autosaveTimer&&(clearInterval(this.autosaveTimer),this.autosaveTimer=null)}async reload(e=!1,t){if(this.semaphores.preventReload)return void(this.semaphores.preventReload=!1);if(this.semaphores.saving)return;if(this.lastLoadedFile=null,this.diskIcon.querySelector("svg").removeClass("excalidraw-dirty"),this.compatibilityMode)return void this.clearDirty();const A=this.excalidrawAPI;if(!this.excalidrawRef||!this.file||!A)return;const i=t&&t===this.file;i&&(this.data=await app.vault.read(t),this.preventAutozoom()),e?await this.excalidrawData.loadData(this.data,this.file,this.textMode):await this.excalidrawData.setTextMode(this.textMode),this.excalidrawData.scene.appState.theme=A.getAppState().theme,await this.loadDrawing(i),this.clearDirty()}async zoomToElementId(e,t){let A=0;for(;!this.excalidrawAPI&&A++<100;)await sleep(50);const i=this.excalidrawAPI;if(!i)return;const n=i.getSceneElements();let a=n.filter((t=>t.id===e));if(0!==a.length){if(t){const e=this.plugin.ea.getElementsInTheSameGroupWithElement(a[0],n);e.length>0&&(a=e)}this.preventAutozoom(),this.zoomToElements(!i.getAppState().viewModeEnabled,a)}}setEphemeralState(e){if(!e)return;const t=this;let A=null;e.match&&e.match.content&&e.match.matches&&1===e.match.matches.length&&2===e.match.matches[0].length&&(A=[e.match.content.substring(e.match.matches[0][0],e.match.matches[0][1])]);const i=async()=>{var e,A;let i=0;for(;(t.semaphores.justLoaded||!t.isLoaded||!t.excalidrawAPI||(null===(A=null===(e=t.excalidrawAPI)||void 0===e?void 0:e.getAppState())||void 0===A?void 0:A.isLoading))&&i++<100;)await sleep(50)},n=getEmbeddedFilenameParts(e.subpath);n.hasBlockref&&setTimeout((async()=>{await i(),setTimeout((()=>t.zoomToElementId(n.blockref,n.hasGroupref)))})),n.hasSectionref?A=[`# ${n.sectionref}`]:e.line&&e.line>0&&(A=[this.data.split("\n")[e.line-1]]),A&&setTimeout((async()=>{await i();const e=t.excalidrawAPI;if(!e)return;if(e.getAppState().isLoading)return;const a=e.getSceneElements();if(1===A.length&&A[0].startsWith("[")){let i=REGEX_LINK.getResList(A[0])[0];if(i){const A=REGEX_LINK.getLink(i);if(A){const i=t.plugin.app.metadataCache.getFirstLinkpathDest(A,t.file.path);if(i){let A=[];if(t.excalidrawData.files.forEach(((e,t)=>{var n;(null===(n=e.file)||void 0===n?void 0:n.path)===i.path&&A.push(t)})),A.length>0){const i=a.filter((e=>"image"===e.type&&A.includes(e.fileId)));i.length>0&&(this.preventAutozoom(),setTimeout((()=>t.zoomToElements(!e.getAppState().viewModeEnabled,i))))}}}}}t.selectElementsMatchingQuery(a,A,!e.getAppState().viewModeEnabled,n.hasSectionref,n.hasGroupref)})),super.setEphemeralState(e)}clear(){this.canvasNodeFactory.purgeNodes(),this.embeddableRefs.clear(),delete this.exportDialog;const e=this.excalidrawAPI;this.excalidrawRef&&e&&(this.activeLoader&&(this.activeLoader.terminate=!0,this.activeLoader=null),this.nextLoader=null,e.resetScene(),this.previousSceneVersion=0)}async setViewData(e,t=!1){this.lastLoadedFile!==this.file&&(this.isLoaded=!1,this.file&&(this.plugin.settings.showNewVersionNotification&&checkExcalidrawVersion(app),t&&this.clear(),this.lastSaveTimestamp=this.file.stat.mtime,this.lastLoadedFile=this.file,e=this.data=e.replaceAll("\r\n","\n").replaceAll("\r","\n"),app.workspace.onLayoutReady((async()=>{if(this.compatibilityMode="excalidraw"===this.file.extension,await this.plugin.loadSettings(),this.compatibilityMode)this.textIsRaw_Element.hide(),this.textIsParsed_Element.hide(),this.linkAction_Element.hide(),this.textMode=TextMode.raw,await this.excalidrawData.loadLegacyData(e,this.file),this.plugin.settings.compatibilityMode||new obsidian_module.Notice(t$d("COMPATIBILITY_MODE"),4e3),this.excalidrawData.disableCompression=!0;else{this.linkAction_Element.show(),this.excalidrawData.disableCompression=!1;const t=getTextMode(e);this.changeTextMode(t,!1);try{if(!await this.excalidrawData.loadData(e,this.file,this.textMode))return}catch(e){if(errorlog({where:"ExcalidrawView.setViewData",error:e}),"iframe conversion canceled"===e.message)return void this.setMarkdownView();const t=this.file,A=this.plugin,i=this.leaf;return(async()=>{let n=!0,a=0;const r=Date.now();for(;!imageCache.isReady()&&n;){const e=`You've been now wating for ${Math.round((Date.now()-r)/1e3)} seconds. `;imageCache.initializationNotice=!0;const t=new ConfirmationPrompt(A,`${a>0?a%4==0?e+"The CACHE is still loading.

":a%4==1?e+"Watch the top rigth corner for the notification.

":a%4==2?e+"I really, really hope the backup will work for you!

":e+"I am sorry, it is taking a while, there is not much I can do...

":""}${t$d("CACHE_NOT_READY")}`);n=await t.waitForClose,a++}const s=await imageCache.getBAKFromCache(t.path);s?new ConfirmationPrompt(A,t$d("BACKUP_AVAILABLE")).waitForClose.then((async e=>{e&&(await app.vault.modify(t,s),A.excalidrawFileModes[i.id||t.path]="excalidraw",A.setExcalidrawView(i))})):new obsidian_module.Notice(`Error loading drawing:\n${e.message}${"Cannot read property 'index' of undefined"===e.message?"\n'# Drawing' section is likely missing":""}\n\nTry manually fixing the file or restoring an earlier version from sync history.`,1e4)})(),void this.setMarkdownView()}}if(await this.loadDrawing(!0),this.plugin.ea.onFileOpenHook)try{await this.plugin.ea.onFileOpenHook({ea:getEA(this),excalidrawFile:this.file,view:this})}catch(e){errorlog({where:"ExcalidrawView.setViewData.onFileOpenHook",error:e})}const t=this.excalidrawData.getOnLoadScript();if(t){const e=this,A=this.file.basename+"-onlaod-script",i=()=>{e.excalidrawAPI?e.plugin.scriptEngine.executeScript(e,t,A,this.file):setTimeout(i,200)};i()}this.isLoaded=!0}))))}getGridColor(e){const t=this.plugin.ea.getCM(e);return t.isDark()?t.lighterBy(5):t.darkerBy(5),t.stringHEX()}async loadSceneFiles(){if(!this.excalidrawAPI)return;const e=new EmbeddedFilesLoader(this.plugin),t=e=>{this.nextLoader=null,this.activeLoader=e,e.loadSceneFiles(this.excalidrawData,((e,A,i=!0)=>{e&&(addFiles(e,this,A),i&&(this.activeLoader=null,this.nextLoader?t(this.nextLoader):this.excalidrawData.getFiles().some((e=>{if(e&&!e.file&&e.attemptCounter<30){const e=this,t=this.file.path;return setTimeout((async()=>{e&&e.excalidrawAPI&&t===e.file.path&&e.loadSceneFiles()}),2e3),!0}return!1}))))}),0)};this.activeLoader?this.nextLoader=e:t(e)}async synchronizeWithData(e){let t=0;for(;this.semaphores.saving&&t++<30;)await sleep(100);if(t>=30)return void errorlog({where:"ExcalidrawView.synchronizeWithData",message:`Aborting sync with received file (${this.file.path}) because semaphores.saving remained true for ower 3 seconds`,fn:this.synchronizeWithData});this.semaphores.saving=!0;let A=!1;try{const t=e.deletedElements.map((e=>e.id)),i=this.excalidrawAPI.getSceneElementsIncludingDeleted().filter((e=>!t.contains(e.id))),n=i.map((e=>e.id)),a=t=>{switch(t.type){case"text":this.excalidrawData.textElements.set(t.id,e.textElements.get(t.id));break;case"image":e.getFile(t.fileId)?(this.excalidrawData.setFile(t.fileId,e.getFile(t.fileId)),A=!0):e.getEquation(t.fileId)&&(this.excalidrawData.setEquation(t.fileId,e.getEquation(t.fileId)),A=!0)}e.elementLinks.has(t.id)&&this.excalidrawData.elementLinks.set(t.id,e.elementLinks.get(t.id))};e.scene.elements.forEach(((t,r,s)=>{const o=i.filter((e=>e.id===t.id))[0];if(o&&(o.version0&&a.viewModeEnabled,l=this.isLoaded?s.getAppState().zenModeEnabled:a.zenModeEnabled;s.setLocalFont(this.plugin.settings.experimentalEnableFourthFont),this.updateScene({elements:n.elements.concat(null!=t?t:[]),files:n.files,commitToHistory:!0},e),this.updateScene({appState:Object.assign(Object.assign(Object.assign({},n.appState),this.excalidrawData.selectedElementIds?this.excalidrawData.selectedElementIds:{}),{zenModeEnabled:l,viewModeEnabled:o,linkOpacity:this.excalidrawData.getLinkOpacity(),trayModeEnabled:this.plugin.settings.defaultTrayMode,penMode:r,penDetected:r,allowPinchZoom:this.plugin.settings.allowPinchZoom,allowWheelZoom:this.plugin.settings.allowWheelZoom,pinnedScripts:this.plugin.settings.pinnedScripts,customPens:this.plugin.settings.customPens.slice(0,this.plugin.settings.numberOfCustomPens)})}),app.workspace.getActiveViewOfType(ExcalidrawView)===this.leaf.view&&this.excalidrawWrapperRef&&(null===(i=null===(A=this.excalidrawWrapperRef.current)||void 0===A?void 0:A.firstElementChild)||void 0===i||i.focus()),this.onAfterLoadScene()}else this.instantiateExcalidraw({elements:n.elements,appState:Object.assign(Object.assign({},n.appState),{zenModeEnabled:a.zenModeEnabled,viewModeEnabled:n.elements.length>0&&a.viewModeEnabled,linkOpacity:this.excalidrawData.getLinkOpacity(),trayModeEnabled:this.plugin.settings.defaultTrayMode,penMode:r,penDetected:r,allowPinchZoom:this.plugin.settings.allowPinchZoom,allowWheelZoom:this.plugin.settings.allowWheelZoom,pinnedScripts:this.plugin.settings.pinnedScripts,customPens:this.plugin.settings.customPens.slice(0,this.plugin.settings.numberOfCustomPens)}),files:n.files,libraryItems:await this.getLibrary()});const o=null!==this.data.match(/```compressed\-json\n/gm);this.compatibilityMode||this.plugin.settings.compress===o||this.isEditedAsMarkdownInOtherView()||this.setDirty(4)}isEditedAsMarkdownInOtherView(){return app.workspace.getLeavesOfType("markdown").filter((e=>e.view.file===this.file)).length>0}onAfterLoadScene(){this.loadSceneFiles(),this.updateContainerSize(null,!0),this.initializeToolsIconPanelAfterLoading()}setDirty(e){var t,A;this.semaphores.dirty=null===(t=this.file)||void 0===t?void 0:t.path,this.diskIcon.querySelector("svg").addClass("excalidraw-dirty"),!this.semaphores.viewunload&&(null===(A=this.toolsPanelRef)||void 0===A?void 0:A.current)&&this.toolsPanelRef.current.setDirty(!0),app.isMobile||obsidian_module.requireApiVersion("0.16.0")&&(this.leaf.tabHeaderInnerTitleEl.style.color="var(--color-accent)")}clearDirty(){var e;if(this.semaphores.viewunload)return;const t=this.excalidrawAPI;if(!t)return;this.semaphores.dirty=null,(null===(e=this.toolsPanelRef)||void 0===e?void 0:e.current)&&this.toolsPanelRef.current.setDirty(!1);const A=t.getSceneElements();A&&(this.previousSceneVersion=this.getSceneVersion(A)),this.diskIcon.querySelector("svg").removeClass("excalidraw-dirty"),app.isMobile||obsidian_module.requireApiVersion("0.16.0")&&(this.leaf.tabHeaderInnerTitleEl.style.color="")}initializeToolsIconPanelAfterLoading(){var e;if(this.semaphores.viewunload)return;const t=this.excalidrawAPI;if(!t)return;const A=t.getAppState(),i=null===(e=this.toolsPanelRef)||void 0===e?void 0:e.current;i&&(i.setTheme(A.theme),i.setExcalidrawViewMode(A.viewModeEnabled),i.setPreviewMode(this.compatibilityMode?null:this.textMode===TextMode.parsed),i.updateScriptIconMap(this.plugin.scriptEngine.scriptIconMap))}canAcceptExtension(e){return"excalidraw"===e}getDisplayText(){return this.file?this.file.basename:t$d("NOFILE")}getViewType(){return"excalidraw"}getIcon(){return ICON_NAME}setMarkdownView(){this.plugin.excalidrawFileModes[this.id||this.file.path]="markdown",this.plugin.setMarkdownView(this.leaf)}async openAsMarkdown(){!0===this.plugin.settings.compress&&(this.excalidrawData.disableCompression=!0,await this.save(!0,!0)),this.setMarkdownView()}async convertExcalidrawToMD(){await this.save(),this.plugin.openDrawing(await this.plugin.convertSingleExcalidrawToMD(this.file),"active-pane",!0)}async addYouTubeThumbnail(e){const t=await getYouTubeThumbnailLink(e),A=getEA(this),i=await A.addImage(0,0,t);A.getElement(i).link=e,A.addElementsToView(!0,!0,!0)}async addImageWithURL(e){const t=getEA(this);await t.addImage(0,0,e),t.addElementsToView(!0,!0,!0)}async addImageSaveToVault(e){const t=getEA(this),A=getMimeType(getURLImageExtension(e)),i=await getDataURLFromURL(e,A,3e3),n=await generateIdFromFile((new TextEncoder).encode(i)),a=await this.excalidrawData.saveDataURLtoVault(i,A,n);a?(await t.addImage(0,0,a),t.addElementsToView(!0,!0,!0)):new obsidian_module.Notice(t$d("ERROR_SAVING_IMAGE"))}async addTextWithIframely(e){var t;const A=await this.addText(e),i=`http://iframely.server.crestify.com/iframely?url=${e}`;try{const n=JSON.parse(await obsidian_module.request({url:i}));if(!n||n.error||!(null===(t=n.meta)||void 0===t?void 0:t.title))return;const a=getEA(this),r=a.getViewElements().filter((e=>e.id===A));1===r.length&&(r[0].text=r[0].originalText=r[0].rawText=`[${n.meta.title}](${e})`,a.copyViewElementsToEAforEditing(r),a.addElementsToView(!1,!1,!1))}catch(e){}}onPaneMenu(e,t){this.excalidrawAPI&&this.getViewSelectedElements().some((e=>"text"===e.type))&&e.addItem((e=>{e.setTitle(t$d("OPEN_LINK")).setIcon("external-link").setSection("pane").onClick((e=>{this.handleLinkClick(e)}))})),this.compatibilityMode?e.addItem((e=>{e.setTitle(t$d("CONVERT_FILE")).onClick((()=>this.convertExcalidrawToMD())).setSection("pane")})):e.addItem((e=>{e.setTitle(t$d("OPEN_AS_MD")).setIcon("document").onClick((()=>{this.openAsMarkdown()})).setSection("pane")})),e.addItem((e=>{e.setTitle(t$d("EXPORT_IMAGE")).setIcon("export-img").setSection("pane").onClick((async e=>{this.getScene&&this.file&&(this.exportDialog||(this.exportDialog=new ExportDialog(this.plugin,this,this.file),this.exportDialog.createForm()),this.exportDialog.open())})).setSection("pane")})).addItem((e=>{e.setTitle(t$d("INSTALL_SCRIPT_BUTTON")).setIcon("ScriptEngine").setSection("pane").onClick((()=>{new ScriptInstallPrompt(this.plugin).open()}))})),super.onPaneMenu(e,t)}async getLibrary(){var e;const t=this.plugin.getStencilLibrary();return(null==t?void 0:t.library)?t.library:null!==(e=null==t?void 0:t.libraryItems)&&void 0!==e?e:[]}async instantiateExcalidraw(e){for(;!this.semaphores.scriptsReady;)await sleep(50);const t=this.plugin.getPackage(this.ownerWindow).react,A=this.plugin.getPackage(this.ownerWindow).reactDOM;this.clearDirty();const i=t.createElement((()=>{const A=t.useRef(null),i=t.useRef(null),n=t.useRef(null),[a,r]=t.useState({width:void 0,height:void 0});let s=null,o=null,l=null,c=Date.now(),d=!1;this.toolsPanelRef=i,this.embeddableMenuRef=n,this.obsidianMenu=new ObsidianMenu(this.plugin,i,this),this.embeddableMenu=new EmbeddableMenu(this,n);const h=()=>{let e,t;const A=new Promise(((A,i)=>{e=A,t=i}));return A.resolve=e,A.reject=t,A},u=t.useMemo((()=>({current:{readyPromise:h()}})),[]);t.useEffect((()=>{u.current.readyPromise.then((e=>{this.excalidrawAPI=e,e.setLocalFont(this.plugin.settings.experimentalEnableFourthFont),setTimeout((()=>{var e,t,A;this.onAfterLoadScene(),this.excalidrawContainer=null===(t=null===(e=this.excalidrawWrapperRef)||void 0===e?void 0:e.current)||void 0===t?void 0:t.firstElementChild,null===(A=this.excalidrawContainer)||void 0===A||A.focus()}))}))}),[u]),this.excalidrawRef=u,this.excalidrawWrapperRef=A,t.useEffect((()=>{r({width:this.contentEl.clientWidth,height:this.contentEl.clientHeight});const e=()=>{try{const e=this.contentEl.clientWidth,t=this.contentEl.clientHeight;if(0===e||0===t)return;r({width:e,height:t}),this.toolsPanelRef&&this.toolsPanelRef.current&&this.toolsPanelRef.current.updatePosition(),this.ownerDocument!==document&&this.refresh()}catch(e){errorlog({where:"Excalidraw React-Wrapper, onResize",error:e})}};return this.ownerWindow.addEventListener("resize",e),()=>{var t;return null===(t=this.ownerWindow)||void 0===t?void 0:t.removeEventListener("resize",e)}}),[A]),this.getSelectedTextElement=()=>{var e;const t=this.excalidrawAPI;if(!(null==u?void 0:u.current)||!t)return{id:null,text:null};if(t.getAppState().viewModeEnabled){if(s){const e=s;return s=null,e}return{id:null,text:null}}const A=t.getSceneElements().filter((e=>e.id===Object.keys(t.getAppState().selectedElementIds)[0]));if(0===A.length)return{id:null,text:null};if("text"===A[0].type)return{id:A[0].id,text:A[0].text};if(["image","arrow"].contains(A[0].type))return{id:null,text:null};const i=null===(e=A[0].boundElements)||void 0===e?void 0:e.filter((e=>"text"===e.type));if((null==i?void 0:i.length)>0){const e=t.getSceneElements().filter((e=>e.id===i[0].id));if(e.length>0)return{id:e[0].id,text:e[0].text}}if(0===A[0].groupIds.length)return{id:null,text:null};const n=A[0].groupIds[0],a=t.getSceneElements().filter((e=>{var t;return null===(t=e.groupIds)||void 0===t?void 0:t.includes(n)})).filter((e=>"text"===e.type));return 0===a.length?{id:null,text:null}:{id:A[0].id,text:A[0].text}},this.getSelectedImageElement=()=>{const e=this.excalidrawAPI;if(!e)return{id:null,fileId:null};if(e.getAppState().viewModeEnabled){if(o){const e=o;return o=null,e}return{id:null,fileId:null}}const t=e.getSceneElements().filter((t=>t.id==Object.keys(e.getAppState().selectedElementIds)[0]));if(0===t.length)return{id:null,fileId:null};if("image"==t[0].type)return{id:t[0].id,fileId:t[0].fileId};if("text"===t[0].type)return{id:null,fileId:null};if(0===t[0].groupIds.length)return{id:null,fileId:null};const A=t[0].groupIds[0],i=e.getSceneElements().filter((e=>{var t;return null===(t=e.groupIds)||void 0===t?void 0:t.includes(A)})).filter((e=>"image"==e.type));return 0===i.length?{id:null,fileId:null}:{id:i[0].id,fileId:i[0].fileId}},this.getSelectedElementWithLink=()=>{const e=this.excalidrawAPI;if(!e)return{id:null,text:null};if(e.getAppState().viewModeEnabled){if(l){const e=l;return l=null,e}return{id:null,text:null}}const t=e.getSceneElements().filter((t=>t.id==Object.keys(e.getAppState().selectedElementIds)[0]));if(0===t.length)return{id:null,text:null};if(t[0].link)return{id:t[0].id,text:t[0].link};if(0===t[0].groupIds.length)return{id:null,text:null};const A=t[0].groupIds[0],i=e.getSceneElements().filter((e=>{var t;return null===(t=e.groupIds)||void 0===t?void 0:t.includes(A)})).filter((e=>e.link));return 0===i.length?{id:null,text:null}:{id:i[0].id,text:i[0].link}},this.addText=async(e,t,A=!0)=>{var i,n,a,r,s;const o=this.excalidrawAPI;if(!(null==u?void 0:u.current)||!o)return;const l=o.getAppState(),c=this.plugin.ea.getAPI(this);c.style.strokeColor=null!==(i=l.currentItemStrokeColor)&&void 0!==i?i:"black",c.style.opacity=null!==(n=l.currentItemOpacity)&&void 0!==n?n:1,c.style.fontFamily=null!==(a=null!=t?t:l.currentItemFontFamily)&&void 0!==a?a:1,c.style.fontSize=null!==(r=l.currentItemFontSize)&&void 0!==r?r:20,c.style.textAlign=null!==(s=l.currentItemTextAlign)&&void 0!==s?s:"left";const{width:d,height:h}=l,g=viewportCoordsToSceneCoords({clientX:0,clientY:0},l),p=viewportCoordsToSceneCoords({clientX:d,clientY:h},l),m=g.x>this.currentPosition.x||p.xthis.currentPosition.y||p.y{const r=this.excalidrawAPI;if(!(null==u?void 0:u.current)||!r)return!1;const s=e.filter((e=>"text"==e.type));for(let e=0;ee.id)),l=r.getSceneElements(),c=[];for(let t=0;te.id===A))[0],c.push(A))}const d=n?l.concat(e.filter((e=>!c.includes(e.id)))):e.filter((e=>!c.includes(e.id))).concat(l);if(this.updateScene({elements:d,commitToHistory:!0},a),i&&Object.keys(i).length>0){const e=[];Object.keys(i).forEach((t=>{if(e.push({mimeType:i[t].mimeType,id:i[t].id,dataURL:i[t].dataURL,created:i[t].created}),i[t].file||i[t].isHyperlink){const e=new EmbeddedFile(this.plugin,this.file.path,i[t].isHyperlink?i[t].hyperlink:i[t].file),A=r.getAppState();e.setImage(i[t].dataURL,i[t].mimeType,i[t].size,"dark"===A.theme,i[t].hasSVGwithBitmap),this.excalidrawData.setFile(i[t].id,e)}i[t].latex&&this.excalidrawData.setEquation(i[t].id,{latex:i[t].latex,isLoaded:!0})})),r.addFiles(e)}return r.updateContainerSize(r.getSceneElements().filter((e=>o.includes(e.id))).filter(isContainer)),A?await this.save(!1):this.setDirty(5),!0},this.getScene=e=>{const t=this.excalidrawAPI;if(!(null==u?void 0:u.current)||!t)return null;const A=e?this.getViewSelectedElements():t.getSceneElements(),i=t.getAppState(),n=Object.assign({},t.getFiles());if(n){const e=A.filter((e=>"image"===e.type)).map((e=>e.fileId)),t=Object.keys(n).filter((t=>!e.contains(t)));t.forEach((e=>delete n[e]))}return{type:"excalidraw",version:2,source:GITHUB_RELEASES+PLUGIN_VERSION,elements:A,appState:{theme:i.theme,viewBackgroundColor:i.viewBackgroundColor,currentItemStrokeColor:i.currentItemStrokeColor,currentItemBackgroundColor:i.currentItemBackgroundColor,currentItemFillStyle:i.currentItemFillStyle,currentItemStrokeWidth:i.currentItemStrokeWidth,currentItemStrokeStyle:i.currentItemStrokeStyle,currentItemRoughness:i.currentItemRoughness,currentItemOpacity:i.currentItemOpacity,currentItemFontFamily:i.currentItemFontFamily,currentItemFontSize:i.currentItemFontSize,currentItemTextAlign:i.currentItemTextAlign,currentItemStartArrowhead:i.currentItemStartArrowhead,currentItemEndArrowhead:i.currentItemEndArrowhead,scrollX:i.scrollX,scrollY:i.scrollY,zoom:i.zoom,currentItemRoundness:i.currentItemRoundness,gridSize:i.gridSize,colorPalette:i.colorPalette,currentStrokeOptions:i.currentStrokeOptions,previousGridSize:i.previousGridSize},prevTextMode:this.prevTextMode,files:n}},this.refresh=()=>{if(0===this.contentEl.clientWidth||0===this.contentEl.clientHeight)return;const e=this.excalidrawAPI;(null==u?void 0:u.current)&&e&&e.refresh()};let g={x:0,y:0},p=null;this.clearHoverPreview=()=>{if(p){const e=new MouseEvent("click",{view:this.ownerWindow,bubbles:!0,cancelable:!0});p.dispatchEvent(e),p=null}};const m=e=>{var t,A,i,n,a;const r=null===(t=app.dragManager.draggable)||void 0===t?void 0:t.files;return r&&r[0]==this.file&&(r.shift(),app.dragManager.draggable.title=`${r.length} files`),["file","files"].includes(null===(A=app.dragManager.draggable)||void 0===A?void 0:A.type)?"link":(null===(i=e.types)||void 0===i?void 0:i.includes("text/html"))||(null===(n=e.types)||void 0===n?void 0:n.includes("text/plain"))||(null===(a=e.types)||void 0===a?void 0:a.includes("Files"))?"copy":void 0};let w=!1;const f=()=>{if(s=getTextElementAtPointer(this.currentPosition,this),s&&s.id){const e=new MouseEvent("click",{ctrlKey:!(DEVICE.isIOS||DEVICE.isMacOS)||this.modifierKeyDown.ctrlKey,metaKey:DEVICE.isIOS||DEVICE.isMacOS||this.modifierKeyDown.metaKey,shiftKey:this.modifierKeyDown.shiftKey,altKey:this.modifierKeyDown.altKey});return this.handleLinkClick(e),void(s=null)}if(o=getImageElementAtPointer(this.currentPosition,this),o&&o.id){const e=new MouseEvent("click",{ctrlKey:!(DEVICE.isIOS||DEVICE.isMacOS)||this.modifierKeyDown.ctrlKey,metaKey:DEVICE.isIOS||DEVICE.isMacOS||this.modifierKeyDown.metaKey,shiftKey:this.modifierKeyDown.shiftKey,altKey:this.modifierKeyDown.altKey});return this.handleLinkClick(e),void(o=null)}if(l=getElementWithLinkAtPointer(this.currentPosition,this),l&&l.id){const e=new MouseEvent("click",{ctrlKey:!(DEVICE.isIOS||DEVICE.isMacOS)||this.modifierKeyDown.ctrlKey,metaKey:DEVICE.isIOS||DEVICE.isMacOS||this.modifierKeyDown.metaKey,shiftKey:this.modifierKeyDown.shiftKey,altKey:this.modifierKeyDown.altKey});return this.handleLinkClick(e),void(l=null)}};let E=null;const B=(e,t)=>{var A,i;if(!E)return;if(null===(i=null===(A=this.excalidrawAPI)||void 0===A?void 0:A.getAppState())||void 0===i?void 0:i.editingElement)return;if(this.semaphores.wheelTimeout)return;if(!e){if(!this.currentPosition)return;e="";const A=getTextElementAtPointer(this.currentPosition,this);if(A&&A.text){t=this.excalidrawAPI.getSceneElements().filter((e=>e.id===A.id))[0];const i=this.textMode===TextMode.parsed?this.excalidrawData.getRawText(A.id):A.text;if(!i)return;if(i.match(REG_LINKINDEX_HYPERLINK))return;const n=REGEX_LINK.getRes(i).next();if(!n.value)return;if((e=REGEX_LINK.getLink(n)).match(REG_LINKINDEX_HYPERLINK))return}else{const A=getImageElementAtPointer(this.currentPosition,this);if(t=this.excalidrawAPI.getSceneElements().filter((e=>e.id===A.id))[0],!A||!A.fileId)return;if(!this.excalidrawData.hasFile(A.fileId))return;const i=this.excalidrawData.getFile(A.fileId);if(i.isHyperlink)return;if(IMAGE_TYPES.contains(i.file.extension))return;if("pdf"===i.file.extension.toLowerCase())return;if(this.plugin.ea.isExcalidrawFile(i.file))return;const n=i.linkParts.ref?`#${i.linkParts.isBlockRef?"^":""}${i.linkParts.ref}`:"";e=i.file.path+n}}if(this.getHookServer().onLinkHoverHook)try{if(!this.getHookServer().onLinkHoverHook(t,e,this,this.getHookServer()))return}catch(e){errorlog({where:"ExcalidrawView.showHoverPreview",fn:this.getHookServer().onLinkHoverHook,error:e})}if(this.semaphores.hoverSleep)return;const n=app.metadataCache.getFirstLinkpathDest(e.split("#")[0],this.file.path);if(!n)return;if(this.ownerDocument.querySelector(`div.popover-title[data-path="${n.path}"]`))return;this.semaphores.hoverSleep=!0;const a=this;if(setTimeout((()=>a.semaphores.hoverSleep=!1),500),this.plugin.hover.linkText=e,this.plugin.hover.sourcePath=this.file.path,p=this.contentEl,app.workspace.trigger("hover-link",{event:E,source:"excalidraw",hoverParent:p,targetEl:p,linktext:this.plugin.hover.linkText,sourcePath:this.plugin.hover.sourcePath}),g=this.currentPosition,this.isFullscreen()){const e=this;setTimeout((()=>{var t,A,i,a;const r=null!==(a=null===(i=null===(A=null===(t=this.ownerDocument.querySelector(`div.popover-title[data-path="${n.path}"]`))||void 0===t?void 0:t.parentElement)||void 0===A?void 0:A.parentElement)||void 0===i?void 0:i.parentElement)&&void 0!==a?a:this.ownerDocument.body.querySelector("div.popover");r&&e.contentEl.append(r)}),400)}},{Excalidraw:b,MainMenu:v,WelcomeScreen:C}=this.plugin.getPackage(this.ownerWindow).excalidrawLib,y=t.createElement("div",{className:"excalidraw-wrapper",ref:A,key:"abc",tabIndex:0,onKeyDown:e=>{e.target!==y.ref.current&&(this.isFullscreen()&&e.keyCode===KEYCODE.ESC&&this.exitFullscreen(),!isCTRL(e)||isSHIFT(e)||isALT(e)||B())},onPointerDown:e=>{(isCTRL(e)||isMETA(e))&&(!this.plugin.settings.allowCtrlClick&&isMETA(e)||setTimeout((()=>{(this.getSelectedTextElement().id||this.getSelectedImageElement().id||this.getSelectedElementWithLink().id)&&this.handleLinkClick(e)})))},onMouseMove:e=>{E=e.nativeEvent},onMouseOver:()=>{this.clearHoverPreview()},onDragOver:e=>{const t=m(e.dataTransfer);if(t){this.draginfoDiv||(this.draginfoDiv=createDiv({cls:"excalidraw-draginfo"}),this.ownerDocument.body.appendChild(this.draginfoDiv));let A="";if(app.dragManager.draggable)switch(internalDragModifierType(e)){case"image":A="Embed image";break;case"image-fullsize":A="Embed image @100%";break;case"link":A="Insert link\n"+(DEVICE.isMacOS||DEVICE.isIOS?"try SHIFT and CTRL combinations for other drop actions":"try SHIFT, CTRL, ALT combinations for other drop actions");break;case"embeddable":A="Insert in interactive frame"}else if(1===e.dataTransfer.types.length&&e.dataTransfer.types.includes("Files"))A="External file";else switch(externalDragModifierType(e)){case"image-import":A="Import image to Vault";break;case"image-url":A="Insert image/thumbnail with URL\n"+(DEVICE.isMacOS||DEVICE.isIOS?"try SHIFT, OPT, CTRL combinations for other drop actions":"try SHIFT, CTRL, ALT combinations for other drop actions");break;case"insert-link":A="Insert link";break;case"embeddable":A="Insert in interactive frame"}this.draginfoDiv.innerText!==A&&(this.draginfoDiv.innerText=A);const i=e.clientY-8*parseFloat(getComputedStyle(this.draginfoDiv).fontSize)+"px",n=e.clientX-this.draginfoDiv.clientWidth/2+"px";return this.draginfoDiv.style.top!==i&&(this.draginfoDiv.style.top=i),this.draginfoDiv.style.left!==n&&(this.draginfoDiv.style.left=n),e.dataTransfer.dropEffect=t,e.preventDefault(),!1}},onDragLeave:()=>{this.draginfoDiv&&(this.ownerDocument.body.removeChild(this.draginfoDiv),delete this.draginfoDiv)}},t.createElement(b,{ref:u,width:a.width,height:a.height,UIOptions:{canvasActions:{loadScene:!1,saveScene:!1,saveAsScene:!1,export:!1,saveAsImage:!1,saveToActiveFile:!1}},initState:null==e?void 0:e.appState,initialData:e,detectScroll:!0,onPointerUpdate:e=>{if(this.currentPosition=e.pointer,p&&(Math.abs(g.x-e.pointer.x)>50||Math.abs(g.y-e.pointer.y)>50)&&this.clearHoverPreview(),w){if(!d&&"down"===e.button){if(d=!0,isCTRL(this.modifierKeyDown)||isMETA(this.modifierKeyDown))return void f();const e=Date.now();return e-c<600&&e-c>40&&f(),void(c=e)}"up"===e.button&&(d=!1),(isCTRL(this.modifierKeyDown)||this.excalidrawAPI.getAppState().isViewModeEnabled&&this.plugin.settings.hoverPreviewWithoutCTRL)&&B()}},libraryReturnUrl:"app://obsidian.md",autoFocus:!0,onChange:(e,t)=>{var A,i,n,a;const r=()=>{if(setTimeout((()=>this.updateScene({appState:{gridColor:this.getGridColor(t.viewBackgroundColor)}}))),setDynamicStyle(this.plugin.ea,this,t.viewBackgroundColor,this.plugin.settings.dynamicStyling),this.plugin.ea.onCanvasColorChangeHook)try{this.plugin.ea.onCanvasColorChangeHook(this.plugin.ea,this,t.viewBackgroundColor)}catch(e){errorlog({where:r,source:this.plugin.ea.onCanvasColorChangeHook,error:e,message:"ea.onCanvasColorChangeHook exception"})}};if(w=t.viewModeEnabled,this.semaphores.justLoaded){if((null!==(a=null===(n=null===(i=null===(A=this.excalidrawData)||void 0===A?void 0:A.scene)||void 0===i?void 0:i.elements)||void 0===n?void 0:n.length)&&void 0!==a?a:0)>0&&0===e.length)return;return this.semaphores.justLoaded=!1,!this.semaphores.preventAutozoom&&this.plugin.settings.zoomToFitOnOpen&&this.zoomToFit(!1,!0),this.previousSceneVersion=this.getSceneVersion(e),this.previousBackgroundColor=t.viewBackgroundColor,this.previousTheme=t.theme,void r()}if(t.theme!==this.previousTheme&&this.file===this.excalidrawData.file&&(this.previousTheme=t.theme,this.setDirty(5)),t.viewBackgroundColor!==this.previousBackgroundColor&&this.file===this.excalidrawData.file&&(this.previousBackgroundColor=t.viewBackgroundColor,this.setDirty(6),this.colorChangeTimer&&clearTimeout(this.colorChangeTimer),this.colorChangeTimer=setTimeout((()=>{r(),this.colorChangeTimer=null}),50)),!this.semaphores.dirty&&null===t.editingElement&&null===t.editingLinearElement){const t=this.getSceneVersion(e);(t>0||0===t&&e.length>0)&&t!==this.previousSceneVersion&&(this.previousSceneVersion=t,this.setDirty(6))}},onLibraryChange:e=>{(async()=>{const t={type:"excalidrawlib",version:2,source:GITHUB_RELEASES+PLUGIN_VERSION,libraryItems:e};this.plugin.setStencilLibrary(t),await this.plugin.saveSettings()})()},renderTopRightUI:(e,t)=>this.obsidianMenu.renderButton(e,t),renderEmbeddableMenu:e=>this.embeddableMenu.renderButtons(e),onPaste:(e,t)=>{const A=this.getHookServer();if(e&&A.onPasteHook){const i=A.onPasteHook({ea:A,payload:e,event:t,excalidrawFile:this.file,view:this,pointerPosition:this.currentPosition});if("boolean"==typeof i&&!1===i)return!1}if(e&&e.text&&hyperlinkIsImage(e.text))return this.addImageWithURL(e.text),!1;if(e.elements){const e=this;setTimeout((()=>e.save(!1)),300)}return!0},onThemeChange:async e=>{var t;this.excalidrawData.scene.appState.theme=e,this.loadSceneFiles(),null===(t=null==i?void 0:i.current)||void 0===t||t.setTheme(e),setDynamicStyle(this.plugin.ea,this,this.previousBackgroundColor,this.plugin.settings.dynamicStyling)},ownerDocument:this.ownerDocument,ownerWindow:this.ownerWindow,onDrop:e=>{this.draginfoDiv&&(this.ownerDocument.body.removeChild(this.draginfoDiv),delete this.draginfoDiv);const t=this.excalidrawAPI;if(!t)return!1;const A=t.getAppState();this.currentPosition=viewportCoordsToSceneCoords({clientX:e.clientX,clientY:e.clientY},A);const i=app.dragManager.draggable,n=internalDragModifierType(e),a=externalDragModifierType(e),r=(t,A,n)=>{if(!this.getHookServer().onDropHook)return!1;try{return this.getHookServer().onDropHook({ea:this.getHookServer(),event:e,draggable:i,type:t,payload:{files:A,text:n},excalidrawFile:this.file,view:this,pointerPosition:this.currentPosition})}catch(e){return new obsidian_module.Notice("on drop hook error. See console log for details"),errorlog({where:"ExcalidrawView.onDrop",error:e}),!1}};switch(null==i?void 0:i.type){case"file":if(!r("file",[i.file],null)){const e=i.file;if(e.path.match(REG_LINKINDEX_INVALIDCHARS))return new obsidian_module.Notice(t$d("FILENAME_INVALID_CHARS"),4e3),!1;if(["image","image-fullsize"].contains(n)&&(IMAGE_TYPES.contains(e.extension)||"md"===e.extension||"pdf"===e.extension.toLowerCase()))return"pdf"===e.extension.toLowerCase()?new InsertPDFModal(this.plugin,this).open(e):(async()=>{const t=getEA(this);t.selectElementsInView([await insertImageToView(t,this.currentPosition,e,!("image-fullsize"===n))])})(),!1;if("embeddable"===n)return(async()=>{const t=getEA(this);t.selectElementsInView([await insertEmbeddableToView(t,this.currentPosition,e)])})(),!1;this.addText(`[[${app.metadataCache.fileToLinktext(i.file,this.file.path,!0)}]]`)}return!1;case"files":return r("file",i.files,null)||(async()=>{if(["image","image-fullsize"].contains(n)){const e=getEA(this);e.canvas.theme=t.getAppState().theme;let A=0;const a=[];for(const t of i.files)(IMAGE_TYPES.contains(t.extension)||"md"===t.extension)&&(a.push(await e.addImage(this.currentPosition.x+50*A,this.currentPosition.y+50*A,t,!("image-fullsize"===n))),A++,await e.addElementsToView(!1,!1,!0),e.selectElementsInView(a)),"pdf"===t.extension.toLowerCase()&&new InsertPDFModal(this.plugin,this).open(t)}else{if("embeddable"===n){const e=getEA(this);let t=0,A=0;const n=[];for(const a of i.files)n.push(await insertEmbeddableToView(e,{x:this.currentPosition.x+500*t,y:this.currentPosition.y+550*A},a)),t=(t+1)%3,0===t&&A++;return!1}for(const e of i.files)await this.addText(`[[${app.metadataCache.fileToLinktext(e,this.file.path,!0)}]]`,void 0,!1),this.currentPosition.y+=2*A.currentItemFontSize;this.save(!1)}})(),!1}if(e.dataTransfer.types.includes("Files")){if(e.dataTransfer.types.includes("text/plain")){const t=e.dataTransfer.getData("text");if(t&&r("text",null,t))return!1;if(t&&"image-url"===a&&hyperlinkIsImage(t))return this.addImageWithURL(t),!1;if(t&&"insert-link"===a)return this.plugin.settings.iframelyAllowed&&t.match(/^https?:\/\/\S*$/)?(this.addTextWithIframely(t),!1):(this.addText(t),!1);if(t&&"embeddable"===a)return insertEmbeddableToView(getEA(this),this.currentPosition,void 0,t),!1}if(e.dataTransfer.types.includes("text/html")){const t=e.dataTransfer.getData("text/html").match(/src=["']([^"']*)["']/);if(t&&"image-url"===a&&hyperlinkIsImage(t[1]))return this.addImageWithURL(t[1]),!1;if(t&&"insert-link"===a)return this.plugin.settings.iframelyAllowed&&t[1].match(/^https?:\/\/\S*$/)?(this.addTextWithIframely(t[1]),!1):(this.addText(t[1]),!1);if(t&&"embeddable"===a)return insertEmbeddableToView(getEA(this),this.currentPosition,void 0,t[1]),!1}return!0}if(e.dataTransfer.types.includes("text/plain")||e.dataTransfer.types.includes("text/uri-list")||e.dataTransfer.types.includes("text/html")){const t=e.dataTransfer.getData("text/html").match(/src=["']([^"']*)["']/),A=t?t[1]:"",i=e.dataTransfer.getData("text"),n=e.dataTransfer.getData("text/uri-list");let s=t?A:i;if(s&&""!==s||(s=n),!s||""===s)return!0;if(!r("text",null,s)){if(s&&"embeddable"===a&&/^(blob:)?(http|https):\/\/[^\s/$.?#].[^\s]*$/.test(s))return!0;if(s&&"image-url"===a&&hyperlinkIsYouTubeLink(s))return this.addYouTubeThumbnail(s),!1;if(n&&"image-url"===a&&hyperlinkIsYouTubeLink(n))return this.addYouTubeThumbnail(n),!1;if(s&&"image-url"===a&&hyperlinkIsImage(s))return this.addImageWithURL(s),!1;if(n&&"image-url"===a&&hyperlinkIsImage(n))return this.addImageWithURL(n),!1;if(s&&"image-import"===a&&hyperlinkIsImage(s))return this.addImageSaveToVault(s),!1;if(n&&"image-import"===a&&hyperlinkIsImage(n))return this.addImageSaveToVault(n),!1;if(this.plugin.settings.iframelyAllowed&&s.match(/^https?:\/\/\S*$/))return this.addTextWithIframely(s),!1;if(s.startsWith("obsidian://open?vault=")){const t=e.dataTransfer.getData("text/html");if(t){const e=t.match(/href="app:\/\/obsidian\.md\/(.*?)"/);if(2===e.length){const t=decodeURIComponent(e[1]).split("#"),A=app.vault.getAbstractFileByPath(t[0]);if(A&&A instanceof obsidian_module.TFile){const e=app.metadataCache.fileToLinktext(A,this.file.path);return void this.addText(`[[${e+(t.length>1?"#"+t[1]+"|"+e:"")}]]`)}return this.addText(`[[${decodeURIComponent(e[1])}]]`),!1}}const A=s.split("file=");if(2===A.length)return this.addText(`[[${decodeURIComponent(A[1])}]]`),!1}this.addText(s.replace(/(!\[\[.*#[^\]]*\]\])/g,"$1{40}"))}return!1}return!r("unknown",null,null)},onBeforeTextEdit:e=>{var t;if(clearTimeout(this.isEditingTextResetTimer),this.isEditingTextResetTimer=null,this.semaphores.isEditingText=!0,this.compatibilityMode)return null!==(t=e.originalText)&&void 0!==t?t:e.text;return this.excalidrawData.getRawText(e.id)||e.rawText},onBeforeTextSubmit:(e,t,A,i)=>{const n=this.excalidrawAPI;if(!n)return[null,null,null];const a="PASTING EXCALIDRAW ELEMENTS AS A TEXT ELEMENT IS NOT ALLOWED";if(t.startsWith('{"type":"excalidraw/clipboard","elements":[{"'))return setTimeout((()=>{const t=this.excalidrawAPI.getSceneElements(),A=t.filter((t=>t.id===e.id));if(1===A.length){const e=cloneElement(A[0]);e.rawText=a,t[t.indexOf(A[0])]=e,this.excalidrawData.setTextElement(e.id,a,a,(()=>{})),this.updateScene({elements:t}),n.history.clear()}})),[a,a,null];if(this.semaphores.isEditingText=!0,this.isEditingTextResetTimer=setTimeout((()=>{this.semaphores.isEditingText=!1,this.isEditingTextResetTimer=null}),1500),i)return this.excalidrawData.deleteTextElement(e.id),this.setDirty(7),[null,null,null];const r=e.containerId;if(t!==e.text||A!==e.originalText||!this.excalidrawData.getRawText(e.id)){this.setDirty(8);const[i,a,s]=this.excalidrawData.setTextElement(e.id,t,A,(async(t,A)=>{var i,a;if(this.textMode===TextMode.raw)return;const r=this.excalidrawAPI.getSceneElements(),s=r.filter((t=>t.id===e.id));if(1===s.length){const e=cloneElement(s[0]),o=s[0].containerId?null===(a=null===(i=n.getSceneElements().filter((e=>e.id===s[0].containerId)))||void 0===i?void 0:i[0])||void 0===a?void 0:a.type:void 0;this.excalidrawData.updateTextElement(e,t,A,!0,o),r[r.indexOf(s[0])]=e,this.updateScene({elements:r}),e.containerId&&this.updateContainerSize(e.containerId)}n.history.clear()}));return i?(r&&this.updateContainerSize(r,!0),this.textMode===TextMode.raw?[t,A,s]:t===i?s?[i,a,s]:[null,null,null]:(n.history.clear(),[i,a,s])):[null,null,null]}return r&&this.updateContainerSize(r,!0),this.textMode===TextMode.parsed?this.excalidrawData.getParsedText(e.id):[null,null,null]},onLinkOpen:async(e,t)=>{var A;if(t.preventDefault(),!e)return;let i=e.link;if(!i||""===i)return;setTimeout((()=>this.removeLinkTooltip()),500);let n=null===(A=null==t?void 0:t.detail)||void 0===A?void 0:A.nativeEvent;if(!this.handleLinkHookCall(e,e.link,n)&&!this.openExternalLink(e.link,isSHIFT(n)||isCTRL(n)||isMETA(n)||isALT(n)?void 0:e)){if("text"===e.type){const t=e.rawText.replaceAll("\n","");REGEX_LINK.getResList(t).filter((e=>Boolean(e.value))).length>1&&(i=t)}n.shiftKey||n.ctrlKey||n.metaKey||n.altKey||(n={shiftKey:!0,ctrlKey:!1,metaKey:!1,altKey:!1}),this.linkClick(n,null,null,{id:e.id,text:i},emulateCTRLClickForLinks(n))}},onLinkHover:(e,t)=>{if(e&&(this.plugin.settings.hoverPreviewWithoutCTRL||isCTRL(t))){E=t,E.ctrlKey=!(DEVICE.isIOS||DEVICE.isMacOS)||E.ctrlKey,E.metaKey=DEVICE.isIOS||DEVICE.isMacOS||E.metaKey;const A=e.link;if(!A||""===A)return;if(A.startsWith("[[")){const t=A.match(/\[\[(?.*?)\]\]/);if(!t)return;let i=t.groups.link;B(i,e)}}},onViewModeChange:e=>{var t,A;if(this.semaphores.viewunload||null===(A=null===(t=this.toolsPanelRef)||void 0===t?void 0:t.current)||void 0===A||A.setExcalidrawViewMode(e),this.getHookServer().onViewModeChangeHook)try{this.getHookServer().onViewModeChangeHook(e,this,this.getHookServer())}catch(e){errorlog({where:"ExcalidrawView.onViewModeChange",fn:this.getHookServer().onViewModeChangeHook,error:e})}},validateEmbeddable:!0,renderWebview:DEVICE.isDesktop,renderEmbeddable:(e,A)=>{try{const i=useDefaultExcalidrawFrame(e);if(!this.file||!e||!e.link||0===e.link.length||i)return null;if(e.link.match(REG_LINKINDEX_HYPERLINK))return i?null:renderWebView(e.link,this,e.id);const n=REGEX_LINK.getRes(e.link).next();if(!n||!n.value&&n.done)return null;let a=REGEX_LINK.getLink(n);return a.match(REG_LINKINDEX_HYPERLINK)?i?null:renderWebView(a,this,e.id):t.createElement(CustomEmbeddable,{element:e,view:this,appState:A,linkText:a})}catch(e){return null}}},t.createElement(v,{},t.createElement(v.DefaultItems.ChangeCanvasBackground),t.createElement(v.DefaultItems.ToggleTheme),t.createElement(v.Separator),DEVICE.isPhone?null:t.createElement(v.Item,{icon:ICONS.trayMode,"aria-label":"Tray-mode offers an alternative, more spacious canvas",onSelect:()=>{this.toggleTrayMode()}},"Toggle tray-mode"),t.createElement(v.Item,{icon:saveIcon(!1),"aria-label":t$d("FORCE_SAVE"),onSelect:()=>{this.forceSave()}},"Save"),t.createElement(v.Item,{icon:ICONS.scriptEngine,"aria-label":"Explore the Excalidraw Script Library",onSelect:()=>{new ScriptInstallPrompt(this.plugin).open()}},"Script Library"),t.createElement(v.Item,{icon:ICONS.ExportImage,"aria-label":"Export image as PNG, SVG, or Excalidraw file",onSelect:()=>{this.exportDialog||(this.exportDialog=new ExportDialog(this.plugin,this,this.file),this.exportDialog.createForm()),this.exportDialog.open()}},"Export Image..."),t.createElement(v.Item,{icon:ICONS.switchToMarkdown,"aria-label":"Switch to markdown view",onSelect:()=>{this.openAsMarkdown()}},"Open as Markdown"),t.createElement(v.Separator),t.createElement(v.DefaultItems.Help),t.createElement(v.DefaultItems.ClearCanvas)),t.createElement(C,{},t.createElement(C.Center,{},t.createElement(C.Center.Logo),t.createElement(C.Center.Heading,{},'Type "Excalidraw" in the Command Palette',t.createElement("br"),"Explore the Obsidian Menu in the top right",t.createElement("br"),"Visit the Script Library",t.createElement("br"),"Find help in the hamburger-menu"),t.createElement(C.Center.Menu,{},t.createElement(C.Center.MenuItemLink,{icon:ICONS.YouTube,href:"https://www.youtube.com/@VisualPKM",shortcut:null,"aria-label":"Visual PKM YouTube Channel"}," Check out the Visual PKM YouTube channel."),t.createElement(C.Center.MenuItemLink,{icon:ICONS.Discord,href:"https://discord.gg/DyfAXFwUHc",shortcut:null,"aria-label":"Join the Visual Thinking Discord Server"}," Join the Visual Thinking Discord Server"),t.createElement(C.Center.MenuItemLink,{icon:ICONS.twitter,href:"https://twitter.com/zsviczian",shortcut:null,"aria-label":"Follow me on Twitter"}," Follow me on Twitter"),t.createElement(C.Center.MenuItemLink,{icon:ICONS.heart,href:"https://ko-fi.com/zsolt",shortcut:null,"aria-label":"Donate to support Excalidraw-Obsidian"},' Say "Thank You" & support the plugin.'))))),t.createElement(ToolsPanel,{ref:i,visible:!1,view:this,centerPointer:()=>{const e=this.excalidrawAPI;if(!u||!u.current||!e)return;const t=e.getAppState(),{width:A,height:i}=t;this.currentPosition=viewportCoordsToSceneCoords({clientX:A/2,clientY:i/2},t)}})),F=t.useRef(new ResizeObserver((e=>{if(!i||!i.current)return;const{width:t,height:A}=e[0].contentRect;if(0===t||0===A)return;const n=i.current.onRightEdge?i.current.previousWidth-t:0,a=i.current.onBottomEdge?i.current.previousHeight-A:0;i.current.updatePosition(a,n)})));return t.useEffect((()=>((null==i?void 0:i.current)&&F.current.observe(i.current.containerRef.current),()=>{F.current.unobserve(i.current.containerRef.current)})),[i,F]),t.createElement(t.Fragment,null,y)}));A.createRoot(this.contentEl).render(i)}updateContainerSize(e,t=!1){const A=this.excalidrawAPI;if(!A)return;const i=()=>{const t=e?A.getSceneElements().filter((t=>t.id===e&&"arrow"!==t.type)):A.getSceneElements().filter(isContainer);t.length>0&&(this.initialContainerSizeUpdate&&(this.semaphores.justLoaded=!0),A.updateContainerSize(t)),this.initialContainerSizeUpdate=!1};t?setTimeout((()=>i()),50):i()}zoomToFit(e=!0,t=!1){if(document.body.querySelector("div.modal-container"))return;const A=this.excalidrawAPI;if(!A||!this.excalidrawRef||this.semaphores.isEditingText||this.semaphores.preventAutozoom)return;const i=this.plugin.settings.zoomToFitMaxLevel,n=A.getSceneElements().filter((e=>e.width<1e4&&e.height<1e4));app.isMobile&&n.length>1e3||n.length>2500?t&&A.scrollToContent():e?setTimeout((()=>A.zoomToFit(n,i,this.isFullscreen()?0:.05)),100):A.zoomToFit(n,i,this.isFullscreen()?0:.05)}updatePinnedScripts(){const e=this.excalidrawAPI;if(!e)return!1;e.updateScene({appState:{pinnedScripts:this.plugin.settings.pinnedScripts}})}updatePinnedCustomPens(){const e=this.excalidrawAPI;if(!e)return!1;e.updateScene({appState:{customPens:this.plugin.settings.customPens.slice(0,this.plugin.settings.numberOfCustomPens)}})}updatePinchZoom(){const e=this.excalidrawAPI;if(!e)return!1;e.updateScene({appState:{allowPinchZoom:this.plugin.settings.allowPinchZoom}})}updateWheelZoom(){const e=this.excalidrawAPI;if(!e)return!1;e.updateScene({appState:{allowWheelZoom:this.plugin.settings.allowWheelZoom}})}async toggleTrayMode(){const e=this.excalidrawAPI;if(!e)return!1;const t=e.getAppState();e.updateScene({appState:{trayModeEnabled:!t.trayModeEnabled}}),await this.plugin.loadSettings(),this.plugin.settings.defaultTrayMode=!t.trayModeEnabled,this.plugin.saveSettings()}selectElementsMatchingQuery(e,t,A=!0,i=!1,n=!1){let a=getTextElementsMatchingQuery(e.filter((e=>"text"===e.type)),t,i).concat(getFrameElementsMatchingQuery(e.filter((e=>"frame"===e.type)),t,i));if(0!==a.length){if(n){const t=this.plugin.ea.getElementsInTheSameGroupWithElement(a[0],e);t.length>0&&(a=t)}this.zoomToElements(A,a)}else new obsidian_module.Notice("I could not find a matching text element")}zoomToElements(e,t){const A=this.excalidrawAPI;if(!A)return;const i=this.plugin.settings.zoomToFitMaxLevel;e&&A.selectElements(t),A.zoomToFit(t,i,.05)}getViewSelectedElements(){var e;const t=this.excalidrawAPI;if(!t)return[];const A=null===(e=t.getAppState())||void 0===e?void 0:e.selectedElementIds;if(!A)return[];const i=Object.keys(A);if(!i)return[];const n=t.getSceneElements().filter((e=>i.includes(e.id))),a=n.filter((e=>e.boundElements&&e.boundElements.filter((e=>"text"===e.type)).length>0)).map((e=>e.boundElements.filter((e=>"text"===e.type)).map((e=>e.id))[0])),r=n.map((e=>e.id)).concat(a);return t.getSceneElements().filter((e=>r.contains(e.id)))}async copyLinkToSelectedElementToClipboard(e){const t=this.getViewSelectedElements();if(t.length<1)return void new obsidian_module.Notice(t$d("INSERT_LINK_TO_ELEMENT_ERROR"));let A;if(2===t.length){const e=t.filter((e=>"text"===e.type));1===e.length&&e[0].containerId&&1===t.filter((e=>e.boundElements.some((e=>"text"===e.type)))).length&&(A=e[0].id)}A||(A=1===t.length?t[0].id:this.plugin.ea.getLargestElement(t).id);let i=[];if(t.some((e=>e.id===A&&"frame"===e.type)))switch(e){case"area=":case"group=":case"frame=":i=[{caption:"Frame",action:()=>{e="frame="}},{caption:"Link",action:()=>{e=""}}];break;default:i=[{caption:"Link",action:()=>{e=""}},{caption:"Frame",action:()=>{e="frame="}}]}else switch(e){case"area=":i=[{caption:"Area",action:()=>{e="area="}},{caption:"Link",action:()=>{e=""}},{caption:"Group",action:()=>{e="group="}}];break;case"group=":i=[{caption:"Group",action:()=>{e="group="}},{caption:"Link",action:()=>{e=""}},{caption:"Area",action:()=>{e="area="}}];break;default:i=[{caption:"Link",action:()=>{e=""}},{caption:"Area",action:()=>{e="area="}},{caption:"Group",action:()=>{e="group="}}]}const n=await ScriptEngine.inputPrompt(this,this.plugin,app,"Set link alias","Leave empty if you do not want to set an alias","",i);navigator.clipboard.writeText(`${e.length>0?"!":""}[[${this.file.path}#^${e}${A}${n?`|${n}`:""}]]`),new obsidian_module.Notice(t$d("INSERT_LINK_TO_ELEMENT_READY"))}updateScene(e,t=!1){const A=this.excalidrawAPI;if(!A)return;const i=e.elements&&t;i&&(e.elements=A.restore(e).elements);try{A.updateScene(e)}catch(t){if(errorlog({where:"ExcalidrawView.updateScene 1st attempt",fn:this.updateScene,error:t,scene:e,willDoSecondAttempt:!i}),i)warningUnknowSeriousError();else try{e.elements=A.restore(e).elements,A.updateScene(e)}catch(t){errorlog({where:"ExcalidrawView.updateScene 2nd attempt",fn:this.updateScene,error:t,scene:e}),warningUnknowSeriousError()}}}updateEmbeddableRef(e,t){t&&this.embeddableRefs.set(e,t)}getEmbeddableElementById(e){return this.embeddableRefs.get(e)}}function getTextMode(e){return e.search("excalidraw-plugin: parsed\n")>-1||e.search("excalidraw-plugin: locked\n")>-1?TextMode.parsed:TextMode.raw}const DEFAULT_SETTINGS={folder:"Excalidraw",embedUseExcalidrawFolder:!1,templateFilePath:"Excalidraw/Template.excalidraw",scriptFolderPath:"Excalidraw/Scripts",compress:!1,autosave:!0,autosaveInterval:15e3,autosaveIntervalDesktop:15e3,autosaveIntervalMobile:1e4,drawingFilenamePrefix:"Drawing ",drawingEmbedPrefixWithFilename:!0,drawingFilnameEmbedPostfix:" ",drawingFilenameDateTime:"YYYY-MM-DD HH.mm.ss",useExcalidrawExtension:!0,displaySVGInPreview:!0,allowImageCache:!0,displayExportedImageIfAvailable:!1,previewMatchObsidianTheme:!1,width:"400",dynamicStyling:"colorful",isLeftHanded:!1,iframeMatchExcalidrawTheme:!0,matchTheme:!1,matchThemeAlways:!1,matchThemeTrigger:!1,defaultMode:"normal",defaultPenMode:"never",allowPinchZoom:!1,allowWheelZoom:!1,zoomToFitOnOpen:!0,zoomToFitOnResize:!0,zoomToFitMaxLevel:2,linkPrefix:"📍",urlPrefix:"🌐",parseTODO:!1,todo:"☐",done:"🗹",hoverPreviewWithoutCTRL:!1,linkOpacity:1,openInAdjacentPane:!1,openInMainWorkspace:!0,showLinkBrackets:!0,allowCtrlClick:!0,forceWrap:!1,pageTransclusionCharLimit:200,wordWrappingDefault:0,removeTransclusionQuoteSigns:!0,iframelyAllowed:!0,pngExportScale:1,exportWithTheme:!0,exportWithBackground:!0,exportPaddingSVG:10,keepInSync:!1,autoexportSVG:!1,autoexportPNG:!1,autoExportLightAndDark:!1,autoexportExcalidraw:!1,embedType:"excalidraw",embedWikiLink:!0,syncExcalidraw:!1,experimentalFileType:!1,experimentalFileTag:"✏️",experimentalLivePreview:!0,experimentalEnableFourthFont:!1,experimantalFourthFont:"Virgil",fieldSuggester:!0,compatibilityMode:!1,drawingOpenCount:0,library:"deprecated",library2:{type:"excalidrawlib",version:2,source:GITHUB_RELEASES+PLUGIN_VERSION,libraryItems:[]},imageElementNotice:!0,mdSVGwidth:500,mdSVGmaxHeight:800,mdFont:"Virgil",mdFontColor:"Black",mdBorderColor:"Black",mdCSS:"",scriptEngineSettings:{},defaultTrayMode:!0,previousRelease:"0.0.0",showReleaseNotes:!0,showNewVersionNotification:!0,mathjaxSourceURL:"https://cdn.jsdelivr.net/npm/mathjax@3.2.1/es5/tex-svg.js",latexBoilerplate:"\\color{blue}",taskboneEnabled:!1,taskboneAPIkey:"",pinnedScripts:[],customPens:[Object.assign({},PENS.default),Object.assign({},PENS.highlighter),Object.assign({},PENS.finetip),Object.assign({},PENS.fountain),Object.assign({},PENS.marker),Object.assign({},PENS["thick-thin"]),Object.assign({},PENS["thin-thick-thin"]),Object.assign({},PENS.default),Object.assign({},PENS.default),Object.assign({},PENS.default)],numberOfCustomPens:0,pdfScale:4,pdfBorderBox:!0,pdfGapSize:20,pdfLockAfterImport:!0,pdfNumColumns:1,pdfImportScale:.3};class ExcalidrawSettingTab extends obsidian_module.PluginSettingTab{constructor(e,t){super(e,t),this.requestEmbedUpdate=!1,this.requestReloadDrawings=!1,this.requestUpdatePinnedPens=!1,this.requestUpdateDynamicStyling=!1,this.reloadMathJax=!1,this.plugin=t}applySettingsUpdate(e=!1){e&&(this.requestReloadDrawings=!0)}async hide(){if(this.plugin.settings.scriptFolderPath=obsidian_module.normalizePath(this.plugin.settings.scriptFolderPath),"/"!==this.plugin.settings.scriptFolderPath&&""!==this.plugin.settings.scriptFolderPath||(this.plugin.settings.scriptFolderPath="Excalidraw/Scripts"),this.plugin.saveSettings(),this.requestUpdatePinnedPens&&app.workspace.getLeavesOfType("excalidraw").forEach((e=>{e.view instanceof ExcalidrawView&&e.view.updatePinnedCustomPens()})),this.requestUpdateDynamicStyling&&app.workspace.getLeavesOfType("excalidraw").forEach((e=>{e.view instanceof ExcalidrawView&&setDynamicStyle(this.plugin.ea,e.view,e.view.previousBackgroundColor,this.plugin.settings.dynamicStyling)})),this.requestReloadDrawings){const e=app.workspace.getLeavesOfType("excalidraw");for(const t of e)t.view instanceof ExcalidrawView&&(await t.view.save(!1),await t.view.reload(!0));this.requestEmbedUpdate=!0}this.requestEmbedUpdate&&this.plugin.triggerEmbedUpdates(),this.plugin.scriptEngine.updateScriptPath(),this.reloadMathJax&&this.plugin.loadMathJax()}async display(){var e;await this.plugin.loadSettings(),this.requestEmbedUpdate=!1,this.requestReloadDrawings=!1;const{containerEl:t}=this;t.addClass("excalidraw-settings"),this.containerEl.empty();const A=t.createDiv("coffee");A.addClass("ex-coffee-div"),A.createEl("a",{href:"https://ko-fi.com/zsolt"}).createEl("img",{attr:{src:"https://cdn.ko-fi.com/cdn/kofi3.png?v=3"}}).height=45,new obsidian_module.Setting(t).setName(t$d("RELEASE_NOTES_NAME")).setDesc(fragWithHTML(t$d("RELEASE_NOTES_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.showReleaseNotes).onChange((async e=>{this.plugin.settings.showReleaseNotes=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("NEWVERSION_NOTIFICATION_NAME")).setDesc(fragWithHTML(t$d("NEWVERSION_NOTIFICATION_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.showNewVersionNotification).onChange((async e=>{this.plugin.settings.showNewVersionNotification=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("FOLDER_NAME")).setDesc(fragWithHTML(t$d("FOLDER_DESC"))).addText((e=>e.setPlaceholder("Excalidraw").setValue(this.plugin.settings.folder).onChange((async e=>{this.plugin.settings.folder=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("FOLDER_EMBED_NAME")).setDesc(fragWithHTML(t$d("FOLDER_EMBED_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.embedUseExcalidrawFolder).onChange((async e=>{this.plugin.settings.embedUseExcalidrawFolder=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("TEMPLATE_NAME")).setDesc(fragWithHTML(t$d("TEMPLATE_DESC"))).addText((e=>e.setPlaceholder("Excalidraw/Template").setValue(this.plugin.settings.templateFilePath).onChange((async e=>{this.plugin.settings.templateFilePath=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("SCRIPT_FOLDER_NAME")).setDesc(fragWithHTML(t$d("SCRIPT_FOLDER_DESC"))).addText((e=>e.setPlaceholder("Excalidraw/Scripts").setValue(this.plugin.settings.scriptFolderPath).onChange((async e=>{this.plugin.settings.scriptFolderPath=e,this.applySettingsUpdate()})))),this.containerEl.createEl("h1",{text:t$d("SAVING_HEAD")}),new obsidian_module.Setting(t).setName(t$d("COMPRESS_NAME")).setDesc(fragWithHTML(t$d("COMPRESS_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.compress).onChange((async e=>{this.plugin.settings.compress=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("AUTOSAVE_INTERVAL_DESKTOP_NAME")).setDesc(fragWithHTML(t$d("AUTOSAVE_INTERVAL_DESKTOP_DESC"))).addDropdown((e=>e.addOption("15000","Frequent (every 15 seconds)").addOption("60000","Moderate (every 60 seconds)").addOption("300000","Rare (every 5 minutes)").addOption("900000","Practically never (every 15 minutes)").setValue(this.plugin.settings.autosaveIntervalDesktop.toString()).onChange((async e=>{this.plugin.settings.autosaveIntervalDesktop=parseInt(e),this.plugin.settings.autosaveInterval=app.isMobile?this.plugin.settings.autosaveIntervalMobile:this.plugin.settings.autosaveIntervalDesktop,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("AUTOSAVE_INTERVAL_MOBILE_NAME")).setDesc(fragWithHTML(t$d("AUTOSAVE_INTERVAL_MOBILE_DESC"))).addDropdown((e=>e.addOption("10000","Frequent (every 10 seconds)").addOption("30000","Moderate (every 30 seconds)").addOption("60000","Rare (every 1 minute)").addOption("300000","Practically never (every 5 minutes)").setValue(this.plugin.settings.autosaveIntervalMobile.toString()).onChange((async e=>{this.plugin.settings.autosaveIntervalMobile=parseInt(e),this.plugin.settings.autosaveInterval=app.isMobile?this.plugin.settings.autosaveIntervalMobile:this.plugin.settings.autosaveIntervalDesktop,this.applySettingsUpdate()})))),this.containerEl.createEl("h1",{text:t$d("FILENAME_HEAD")}),t.createDiv("",(e=>{e.innerHTML=t$d("FILENAME_DESC")}));const i=()=>`${t$d("FILENAME_SAMPLE")}${getDrawingFilename(this.plugin.settings)}
${t$d("FILENAME_EMBED_SAMPLE")}${getEmbedFilename("{NOTE_NAME}",this.plugin.settings)}`,n=t.createEl("p",{text:""});let a,r,s,o,l,c,d;n.innerHTML=i(),new obsidian_module.Setting(t).setName(t$d("FILENAME_PREFIX_NAME")).setDesc(fragWithHTML(t$d("FILENAME_PREFIX_DESC"))).addText((e=>e.setPlaceholder("Drawing ").setValue(this.plugin.settings.drawingFilenamePrefix).onChange((async t=>{this.plugin.settings.drawingFilenamePrefix=t.replaceAll(/[<>:"/\\|?*]/g,"_"),e.setValue(this.plugin.settings.drawingFilenamePrefix),n.innerHTML=i(),this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("FILENAME_PREFIX_EMBED_NAME")).setDesc(fragWithHTML(t$d("FILENAME_PREFIX_EMBED_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.drawingEmbedPrefixWithFilename).onChange((async e=>{this.plugin.settings.drawingEmbedPrefixWithFilename=e,n.innerHTML=i(),this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("FILENAME_POSTFIX_NAME")).setDesc(fragWithHTML(t$d("FILENAME_POSTFIX_DESC"))).addText((e=>e.setPlaceholder("").setValue(this.plugin.settings.drawingFilnameEmbedPostfix).onChange((async t=>{this.plugin.settings.drawingFilnameEmbedPostfix=t.replaceAll(/[<>:"/\\|?*]/g,"_"),e.setValue(this.plugin.settings.drawingFilnameEmbedPostfix),n.innerHTML=i(),this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("FILENAME_DATE_NAME")).setDesc(fragWithHTML(t$d("FILENAME_DATE_DESC"))).addText((e=>e.setPlaceholder("YYYY-MM-DD HH.mm.ss").setValue(this.plugin.settings.drawingFilenameDateTime).onChange((async t=>{this.plugin.settings.drawingFilenameDateTime=t.replaceAll(/[<>:"/\\|?*]/g,"_"),e.setValue(this.plugin.settings.drawingFilenameDateTime),n.innerHTML=i(),this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("FILENAME_EXCALIDRAW_EXTENSION_NAME")).setDesc(fragWithHTML(t$d("FILENAME_EXCALIDRAW_EXTENSION_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.useExcalidrawExtension).onChange((async e=>{this.plugin.settings.useExcalidrawExtension=e,n.innerHTML=i(),this.applySettingsUpdate()})))),this.containerEl.createEl("h1",{text:t$d("DISPLAY_HEAD")}),new obsidian_module.Setting(t).setName(t$d("DYNAMICSTYLE_NAME")).setDesc(fragWithHTML(t$d("DYNAMICSTYLE_DESC"))).addDropdown((e=>e.addOption("none","Dynamic Styling OFF").addOption("colorful","Match color").addOption("gray","Gray, match tone").setValue(this.plugin.settings.dynamicStyling).onChange((async e=>{this.requestUpdateDynamicStyling=!0,this.plugin.settings.dynamicStyling=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("LEFTHANDED_MODE_NAME")).setDesc(fragWithHTML(t$d("LEFTHANDED_MODE_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.isLeftHanded).onChange((async e=>{this.plugin.settings.isLeftHanded=e,setLeftHandedMode(e),setTimeout((()=>setLeftHandedMode(e))),this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("IFRAME_MATCH_THEME_NAME")).setDesc(fragWithHTML(t$d("IFRAME_MATCH_THEME_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.iframeMatchExcalidrawTheme).onChange((async e=>{this.plugin.settings.iframeMatchExcalidrawTheme=e,this.applySettingsUpdate(!0)})))),new obsidian_module.Setting(t).setName(t$d("MATCH_THEME_NAME")).setDesc(fragWithHTML(t$d("MATCH_THEME_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.matchTheme).onChange((async e=>{this.plugin.settings.matchTheme=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("MATCH_THEME_ALWAYS_NAME")).setDesc(fragWithHTML(t$d("MATCH_THEME_ALWAYS_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.matchThemeAlways).onChange((async e=>{this.plugin.settings.matchThemeAlways=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("MATCH_THEME_TRIGGER_NAME")).setDesc(fragWithHTML(t$d("MATCH_THEME_TRIGGER_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.matchThemeTrigger).onChange((async e=>{this.plugin.settings.matchThemeTrigger=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("DEFAULT_OPEN_MODE_NAME")).setDesc(fragWithHTML(t$d("DEFAULT_OPEN_MODE_DESC"))).addDropdown((e=>e.addOption("normal","Always in normal-mode").addOption("zen","Always in zen-mode").addOption("view","Always in view-mode").addOption("view-mobile","Usually normal, but view-mode on Phone").setValue(this.plugin.settings.defaultMode).onChange((async e=>{this.plugin.settings.defaultMode=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("DEFAULT_PEN_MODE_NAME")).setDesc(fragWithHTML(t$d("DEFAULT_PEN_MODE_DESC"))).addDropdown((e=>e.addOption("never","Never").addOption("mobile","On Obsidian Mobile").addOption("always","Always").setValue(this.plugin.settings.defaultPenMode).onChange((async e=>{this.plugin.settings.defaultPenMode=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("DEFAULT_PINCHZOOM_NAME")).setDesc(fragWithHTML(t$d("DEFAULT_PINCHZOOM_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.allowPinchZoom).onChange((async e=>{this.plugin.settings.allowPinchZoom=e,app.workspace.getLeavesOfType("excalidraw").forEach((e=>{e.view instanceof ExcalidrawView&&e.view.updatePinchZoom()})),this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("DEFAULT_WHEELZOOM_NAME")).setDesc(fragWithHTML(t$d("DEFAULT_WHEELZOOM_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.allowWheelZoom).onChange((async e=>{this.plugin.settings.allowWheelZoom=e,app.workspace.getLeavesOfType("excalidraw").forEach((e=>{e.view instanceof ExcalidrawView&&e.view.updateWheelZoom()})),this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("ZOOM_TO_FIT_ONOPEN_NAME")).setDesc(fragWithHTML(t$d("ZOOM_TO_FIT_ONOPEN_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.zoomToFitOnOpen).onChange((async e=>{this.plugin.settings.zoomToFitOnOpen=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("ZOOM_TO_FIT_NAME")).setDesc(fragWithHTML(t$d("ZOOM_TO_FIT_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.zoomToFitOnResize).onChange((async e=>{this.plugin.settings.zoomToFitOnResize=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("ZOOM_TO_FIT_MAX_LEVEL_NAME")).setDesc(fragWithHTML(t$d("ZOOM_TO_FIT_MAX_LEVEL_DESC"))).addSlider((e=>e.setLimits(.5,10,.5).setValue(this.plugin.settings.zoomToFitMaxLevel).onChange((async e=>{a.innerText=` ${e.toString()}`,this.plugin.settings.zoomToFitMaxLevel=e,this.applySettingsUpdate()})))).settingEl.createDiv("",(e=>{a=e,e.style.minWidth="2.3em",e.style.textAlign="right",e.innerText=` ${this.plugin.settings.zoomToFitMaxLevel.toString()}`})),this.containerEl.createEl("h1",{text:t$d("LINKS_HEAD")}),this.containerEl.createEl("span",void 0,(e=>e.innerHTML=t$d("LINKS_DESC"))),new obsidian_module.Setting(t).setName(t$d("ADJACENT_PANE_NAME")).setDesc(fragWithHTML(t$d("ADJACENT_PANE_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.openInAdjacentPane).onChange((async e=>{this.plugin.settings.openInAdjacentPane=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("MAINWORKSPACE_PANE_NAME")).setDesc(fragWithHTML(t$d("MAINWORKSPACE_PANE_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.openInMainWorkspace).onChange((async e=>{this.plugin.settings.openInMainWorkspace=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(fragWithHTML(t$d("LINK_BRACKETS_NAME"))).setDesc(fragWithHTML(t$d("LINK_BRACKETS_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.showLinkBrackets).onChange((e=>{this.plugin.settings.showLinkBrackets=e,this.applySettingsUpdate(!0)})))),new obsidian_module.Setting(t).setName(t$d("LINK_PREFIX_NAME")).setDesc(fragWithHTML(t$d("LINK_PREFIX_DESC"))).addText((e=>e.setPlaceholder(t$d("INSERT_EMOJI")).setValue(this.plugin.settings.linkPrefix).onChange((e=>{this.plugin.settings.linkPrefix=e,this.applySettingsUpdate(!0)})))),new obsidian_module.Setting(t).setName(t$d("URL_PREFIX_NAME")).setDesc(fragWithHTML(t$d("URL_PREFIX_DESC"))).addText((e=>e.setPlaceholder(t$d("INSERT_EMOJI")).setValue(this.plugin.settings.urlPrefix).onChange((e=>{this.plugin.settings.urlPrefix=e,this.applySettingsUpdate(!0)})))),new obsidian_module.Setting(t).setName(t$d("PARSE_TODO_NAME")).setDesc(fragWithHTML(t$d("PARSE_TODO_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.parseTODO).onChange((e=>{this.plugin.settings.parseTODO=e,r.setDisabled(!e),s.setDisabled(!e),this.applySettingsUpdate(!0)})))),new obsidian_module.Setting(t).setName(t$d("TODO_NAME")).setDesc(fragWithHTML(t$d("TODO_DESC"))).addText((e=>{r=e,e.setPlaceholder(t$d("INSERT_EMOJI")).setValue(this.plugin.settings.todo).onChange((e=>{this.plugin.settings.todo=e,this.applySettingsUpdate(!0)}))})),r.setDisabled(!this.plugin.settings.parseTODO),new obsidian_module.Setting(t).setName(t$d("DONE_NAME")).setDesc(fragWithHTML(t$d("DONE_DESC"))).setDisabled(!this.plugin.settings.parseTODO).addText((e=>{s=e,e.setPlaceholder(t$d("INSERT_EMOJI")).setValue(this.plugin.settings.done).onChange((e=>{this.plugin.settings.done=e,this.applySettingsUpdate(!0)}))})),s.setDisabled(!this.plugin.settings.parseTODO),new obsidian_module.Setting(t).setName(t$d("LINKOPACITY_NAME")).setDesc(fragWithHTML(t$d("LINKOPACITY_DESC"))).addSlider((e=>e.setLimits(0,1,.05).setValue(this.plugin.settings.linkOpacity).onChange((async e=>{o.innerText=` ${e.toString()}`,this.plugin.settings.linkOpacity=e,this.applySettingsUpdate(!0)})))).settingEl.createDiv("",(e=>{o=e,e.style.minWidth="2.3em",e.style.textAlign="right",e.innerText=` ${this.plugin.settings.linkOpacity.toString()}`})),new obsidian_module.Setting(t).setName(t$d("HOVERPREVIEW_NAME")).setDesc(fragWithHTML(t$d("HOVERPREVIEW_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.hoverPreviewWithoutCTRL).onChange((async e=>{this.plugin.settings.hoverPreviewWithoutCTRL=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("LINK_CTRL_CLICK_NAME")).setDesc(fragWithHTML(t$d("LINK_CTRL_CLICK_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.allowCtrlClick).onChange((async e=>{this.plugin.settings.allowCtrlClick=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("TRANSCLUSION_WRAP_NAME")).setDesc(fragWithHTML(t$d("TRANSCLUSION_WRAP_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.forceWrap).onChange((async e=>{this.plugin.settings.forceWrap=e,this.applySettingsUpdate(!0)})))).descEl.innerHTML=`![[doc#^ref]]{number} ${t$d("TRANSCLUSION_WRAP_DESC")}`,new obsidian_module.Setting(t).setName(t$d("PAGE_TRANSCLUSION_CHARCOUNT_NAME")).setDesc(fragWithHTML(t$d("PAGE_TRANSCLUSION_CHARCOUNT_DESC"))).addText((e=>e.setPlaceholder("Enter a number").setValue(this.plugin.settings.pageTransclusionCharLimit.toString()).onChange((async t=>{const A=parseInt(t);if(isNaN(A)&&""!==t)e.setValue(this.plugin.settings.pageTransclusionCharLimit.toString());else{if(this.requestEmbedUpdate=!0,""===t)return this.plugin.settings.pageTransclusionCharLimit=10,void this.applySettingsUpdate(!0);this.plugin.settings.pageTransclusionCharLimit=A,e.setValue(this.plugin.settings.pageTransclusionCharLimit.toString()),this.applySettingsUpdate(!0)}})))),new obsidian_module.Setting(t).setName(t$d("TRANSCLUSION_DEFAULT_WRAP_NAME")).setDesc(fragWithHTML(t$d("TRANSCLUSION_DEFAULT_WRAP_DESC"))).addText((e=>e.setPlaceholder("Enter a number").setValue(this.plugin.settings.wordWrappingDefault.toString()).onChange((async t=>{const A=parseInt(t);if(isNaN(A)&&""!==t)e.setValue(this.plugin.settings.wordWrappingDefault.toString());else{if(this.requestEmbedUpdate=!0,""===t)return this.plugin.settings.wordWrappingDefault=0,void this.applySettingsUpdate(!0);this.plugin.settings.wordWrappingDefault=A,e.setValue(this.plugin.settings.wordWrappingDefault.toString()),this.applySettingsUpdate(!0)}})))),new obsidian_module.Setting(t).setName(t$d("QUOTE_TRANSCLUSION_REMOVE_NAME")).setDesc(fragWithHTML(t$d("QUOTE_TRANSCLUSION_REMOVE_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.removeTransclusionQuoteSigns).onChange((e=>{this.plugin.settings.removeTransclusionQuoteSigns=e,this.requestEmbedUpdate=!0,this.applySettingsUpdate(!0)})))),new obsidian_module.Setting(t).setName(t$d("GET_URL_TITLE_NAME")).setDesc(fragWithHTML(t$d("GET_URL_TITLE_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.iframelyAllowed).onChange((async e=>{this.plugin.settings.iframelyAllowed=e,this.applySettingsUpdate()})))),this.containerEl.createEl("h1",{text:t$d("MD_HEAD")}),this.containerEl.createEl("p",{text:t$d("MD_HEAD_DESC")}),new obsidian_module.Setting(t).setName(t$d("MD_TRANSCLUDE_WIDTH_NAME")).setDesc(fragWithHTML(t$d("MD_TRANSCLUDE_WIDTH_DESC"))).addText((e=>e.setPlaceholder("Enter a number e.g. 500").setValue(this.plugin.settings.mdSVGwidth.toString()).onChange((async t=>{const A=parseInt(t);if(isNaN(A)&&""!==t)e.setValue(this.plugin.settings.mdSVGwidth.toString());else{if(this.requestEmbedUpdate=!0,""===t)return this.plugin.settings.mdSVGwidth=500,void this.applySettingsUpdate(!0);this.plugin.settings.mdSVGwidth=A,this.requestReloadDrawings=!0,e.setValue(this.plugin.settings.mdSVGwidth.toString()),this.applySettingsUpdate(!0)}})))),new obsidian_module.Setting(t).setName(t$d("MD_TRANSCLUDE_HEIGHT_NAME")).setDesc(fragWithHTML(t$d("MD_TRANSCLUDE_HEIGHT_DESC"))).addText((e=>e.setPlaceholder("Enter a number e.g. 800").setValue(this.plugin.settings.mdSVGmaxHeight.toString()).onChange((async t=>{const A=parseInt(t);if(isNaN(A)&&""!==t)e.setValue(this.plugin.settings.mdSVGmaxHeight.toString());else{if(this.requestEmbedUpdate=!0,""===t)return this.plugin.settings.mdSVGmaxHeight=800,void this.applySettingsUpdate(!0);this.plugin.settings.mdSVGmaxHeight=A,this.requestReloadDrawings=!0,e.setValue(this.plugin.settings.mdSVGmaxHeight.toString()),this.applySettingsUpdate(!0)}})))),new obsidian_module.Setting(t).setName(t$d("MD_DEFAULT_FONT_NAME")).setDesc(fragWithHTML(t$d("MD_DEFAULT_FONT_DESC"))).addDropdown((async e=>{e.addOption("Virgil","Virgil"),e.addOption("Cascadia","Cascadia"),this.app.vault.getFiles().filter((e=>["ttf","woff","woff2"].contains(e.extension))).forEach((t=>{e.addOption(t.path,t.name)})),e.setValue(this.plugin.settings.mdFont).onChange((e=>{this.requestReloadDrawings=!0,this.plugin.settings.mdFont=e,this.applySettingsUpdate(!0)}))})),new obsidian_module.Setting(t).setName(t$d("MD_DEFAULT_COLOR_NAME")).setDesc(fragWithHTML(t$d("MD_DEFAULT_COLOR_DESC"))).addText((e=>e.setPlaceholder("CSS Color-name|RGB-HEX").setValue(this.plugin.settings.mdFontColor).onChange((e=>{this.requestReloadDrawings=!0,this.plugin.settings.mdFontColor=e,this.applySettingsUpdate(!0)})))),new obsidian_module.Setting(t).setName(t$d("MD_DEFAULT_BORDER_COLOR_NAME")).setDesc(fragWithHTML(t$d("MD_DEFAULT_BORDER_COLOR_DESC"))).addText((e=>e.setPlaceholder("CSS Color-name|RGB-HEX").setValue(this.plugin.settings.mdBorderColor).onChange((e=>{this.requestReloadDrawings=!0,this.plugin.settings.mdBorderColor=e,this.applySettingsUpdate(!0)})))),new obsidian_module.Setting(t).setName(t$d("MD_CSS_NAME")).setDesc(fragWithHTML(t$d("MD_CSS_DESC"))).addText((e=>e.setPlaceholder("filename of css file in vault").setValue(this.plugin.settings.mdCSS).onChange((e=>{this.requestReloadDrawings=!0,this.plugin.settings.mdCSS=e,this.applySettingsUpdate(!0)})))),this.containerEl.createEl("h1",{text:t$d("EMBED_HEAD")}),new obsidian_module.Setting(t).setName(t$d("EMBED_IMAGE_CACHE_NAME")).setDesc(fragWithHTML(t$d("EMBED_IMAGE_CACHE_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.allowImageCache).onChange((e=>{this.plugin.settings.allowImageCache=e,this.applySettingsUpdate()})))).addButton((e=>e.setButtonText(t$d("EMBED_IMAGE_CACHE_CLEAR")).onClick((()=>{imageCache.clearImageCache()})))).addButton((e=>e.setButtonText(t$d("BACKUP_CACHE_CLEAR")).onClick((()=>{new ConfirmationPrompt(this.plugin,t$d("BACKUP_CACHE_CLEAR_CONFIRMATION")).waitForClose.then((e=>{e&&imageCache.clearBackupCache()}))})))),new obsidian_module.Setting(t).setName(t$d("EMBED_PREVIEW_SVG_NAME")).setDesc(fragWithHTML(t$d("EMBED_PREVIEW_SVG_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.displaySVGInPreview).onChange((async e=>{this.plugin.settings.displaySVGInPreview=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("EMBED_REUSE_EXPORTED_IMAGE_NAME")).setDesc(fragWithHTML(t$d("EMBED_REUSE_EXPORTED_IMAGE_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.displayExportedImageIfAvailable).onChange((async e=>{this.plugin.settings.displayExportedImageIfAvailable=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("PREVIEW_MATCH_OBSIDIAN_NAME")).setDesc(fragWithHTML(t$d("PREVIEW_MATCH_OBSIDIAN_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.previewMatchObsidianTheme).onChange((async e=>{this.plugin.settings.previewMatchObsidianTheme=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("EMBED_WIDTH_NAME")).setDesc(fragWithHTML(t$d("EMBED_WIDTH_DESC"))).addText((e=>e.setPlaceholder("400").setValue(this.plugin.settings.width).onChange((async e=>{this.plugin.settings.width=e,this.applySettingsUpdate(),this.requestEmbedUpdate=!0})))),new obsidian_module.Setting(t).setName(t$d("EMBED_TYPE_NAME")).setDesc(fragWithHTML(t$d("EMBED_TYPE_DESC"))).addDropdown((async e=>{l=e,l.addOption("excalidraw","excalidraw"),this.plugin.settings.autoexportPNG?l.addOption("PNG","PNG"):"PNG"===this.plugin.settings.embedType&&(this.plugin.settings.embedType="excalidraw",this.applySettingsUpdate()),this.plugin.settings.autoexportSVG?l.addOption("SVG","SVG"):"SVG"===this.plugin.settings.embedType&&(this.plugin.settings.embedType="excalidraw",this.applySettingsUpdate()),l.setValue(this.plugin.settings.embedType).onChange((async e=>{this.plugin.settings.embedType=e,this.applySettingsUpdate()}))})),new obsidian_module.Setting(t).setName(t$d("EMBED_WIKILINK_NAME")).setDesc(fragWithHTML(t$d("EMBED_WIKILINK_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.embedWikiLink).onChange((async e=>{this.plugin.settings.embedWikiLink=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("EXPORT_PNG_SCALE_NAME")).setDesc(fragWithHTML(t$d("EXPORT_PNG_SCALE_DESC"))).addSlider((e=>e.setLimits(1,5,.5).setValue(this.plugin.settings.pngExportScale).onChange((async e=>{c.innerText=` ${e.toString()}`,this.plugin.settings.pngExportScale=e,this.applySettingsUpdate()})))).settingEl.createDiv("",(e=>{c=e,e.style.minWidth="2.3em",e.style.textAlign="right",e.innerText=` ${this.plugin.settings.pngExportScale.toString()}`})),new obsidian_module.Setting(t).setName(t$d("EXPORT_BACKGROUND_NAME")).setDesc(fragWithHTML(t$d("EXPORT_BACKGROUND_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.exportWithBackground).onChange((async e=>{this.plugin.settings.exportWithBackground=e,this.applySettingsUpdate(),this.requestEmbedUpdate=!0})))),new obsidian_module.Setting(t).setName(t$d("EXPORT_PADDING_NAME")).setDesc(fragWithHTML(t$d("EXPORT_PADDING_DESC"))).addSlider((e=>e.setLimits(0,50,5).setValue(this.plugin.settings.exportPaddingSVG).onChange((async e=>{d.innerText=` ${e.toString()}`,this.plugin.settings.exportPaddingSVG=e,this.applySettingsUpdate()})))).settingEl.createDiv("",(e=>{d=e,e.style.minWidth="2.3em",e.style.textAlign="right",e.innerText=` ${this.plugin.settings.exportPaddingSVG.toString()}`})),new obsidian_module.Setting(t).setName(t$d("EXPORT_THEME_NAME")).setDesc(fragWithHTML(t$d("EXPORT_THEME_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.exportWithTheme).onChange((async e=>{this.plugin.settings.exportWithTheme=e,this.applySettingsUpdate(),this.requestEmbedUpdate=!0})))),this.containerEl.createEl("h1",{text:t$d("EXPORT_HEAD")}),new obsidian_module.Setting(t).setName(t$d("EXPORT_SYNC_NAME")).setDesc(fragWithHTML(t$d("EXPORT_SYNC_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.keepInSync).onChange((async e=>{this.plugin.settings.keepInSync=e,this.applySettingsUpdate()}))));const h=e=>{let t=0;for(t=0;te.setValue(this.plugin.settings.autoexportSVG).onChange((async e=>{e?l.addOption("SVG","SVG"):("SVG"===this.plugin.settings.embedType&&(l.setValue("excalidraw"),this.plugin.settings.embedType="excalidraw"),h("SVG")),this.plugin.settings.autoexportSVG=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("EXPORT_PNG_NAME")).setDesc(fragWithHTML(t$d("EXPORT_PNG_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.autoexportPNG).onChange((async e=>{e?l.addOption("PNG","PNG"):("PNG"===this.plugin.settings.embedType&&(l.setValue("excalidraw"),this.plugin.settings.embedType="excalidraw"),h("PNG")),this.plugin.settings.autoexportPNG=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("EXPORT_BOTH_DARK_AND_LIGHT_NAME")).setDesc(fragWithHTML(t$d("EXPORT_BOTH_DARK_AND_LIGHT_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.autoExportLightAndDark).onChange((async e=>{this.plugin.settings.autoExportLightAndDark=e,this.applySettingsUpdate()})))),this.containerEl.createEl("h1",{text:t$d("COMPATIBILITY_HEAD")}),new obsidian_module.Setting(t).setName(t$d("COMPATIBILITY_MODE_NAME")).setDesc(fragWithHTML(t$d("COMPATIBILITY_MODE_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.compatibilityMode).onChange((async e=>{this.plugin.settings.compatibilityMode=e,n.innerHTML=i(),this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("EXPORT_EXCALIDRAW_NAME")).setDesc(fragWithHTML(t$d("EXPORT_EXCALIDRAW_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.autoexportExcalidraw).onChange((async e=>{this.plugin.settings.autoexportExcalidraw=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("SYNC_EXCALIDRAW_NAME")).setDesc(fragWithHTML(t$d("SYNC_EXCALIDRAW_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.syncExcalidraw).onChange((async e=>{this.plugin.settings.syncExcalidraw=e,this.applySettingsUpdate()})))),this.containerEl.createEl("h1",{text:t$d("NONSTANDARD_HEAD")}),this.containerEl.createEl("p",{text:t$d("NONSTANDARD_DESC")}),new obsidian_module.Setting(t).setName(t$d("CUSTOM_PEN_NAME")).setDesc(t$d("CUSTOM_PEN_DESC")).addDropdown((e=>e.addOption("0","0").addOption("1","1").addOption("2","2").addOption("3","3").addOption("4","4").addOption("5","5").addOption("6","6").addOption("7","7").addOption("8","8").addOption("9","9").addOption("10","10").setValue(this.plugin.settings.numberOfCustomPens.toString()).onChange((e=>{this.plugin.settings.numberOfCustomPens=parseInt(e),this.requestUpdatePinnedPens=!0,this.applySettingsUpdate(!1)})))),new obsidian_module.Setting(t).setName(t$d("ENABLE_FOURTH_FONT_NAME")).setDesc(fragWithHTML(t$d("ENABLE_FOURTH_FONT_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.experimentalEnableFourthFont).onChange((async e=>{this.requestReloadDrawings=!0,this.plugin.settings.experimentalEnableFourthFont=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("FOURTH_FONT_NAME")).setDesc(fragWithHTML(t$d("FOURTH_FONT_DESC"))).addDropdown((async e=>{e.addOption("Virgil","Virgil"),this.app.vault.getFiles().filter((e=>["ttf","woff","woff2"].contains(e.extension))).forEach((t=>{e.addOption(t.path,t.name)})),e.setValue(this.plugin.settings.experimantalFourthFont).onChange((e=>{this.requestReloadDrawings=!0,this.plugin.settings.experimantalFourthFont=e,this.applySettingsUpdate(!0),this.plugin.initializeFourthFont()}))})),this.containerEl.createEl("h1",{text:t$d("EXPERIMENTAL_HEAD")}),this.containerEl.createEl("p",{text:t$d("EXPERIMENTAL_DESC")}),new obsidian_module.Setting(t).setName(t$d("MATHJAX_NAME")).setDesc(t$d("MATHJAX_DESC")).addDropdown((e=>{e.addOption("https://cdn.jsdelivr.net/npm/mathjax@3.2.1/es5/tex-svg.js","jsdelivr").addOption("https://unpkg.com/mathjax@3.2.1/es5/tex-svg.js","unpkg").addOption("https://cdnjs.cloudflare.com/ajax/libs/mathjax/3.2.1/es5/tex-svg-full.min.js","cdnjs").setValue(this.plugin.settings.mathjaxSourceURL).onChange((e=>{this.plugin.settings.mathjaxSourceURL=e,this.reloadMathJax=!0,this.applySettingsUpdate()}))})),new obsidian_module.Setting(t).setName(t$d("LATEX_DEFAULT_NAME")).setDesc(fragWithHTML(t$d("LATEX_DEFAULT_DESC"))).addText((e=>e.setValue(this.plugin.settings.latexBoilerplate).onChange((e=>{this.plugin.settings.latexBoilerplate=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("FIELD_SUGGESTER_NAME")).setDesc(fragWithHTML(t$d("FIELD_SUGGESTER_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.fieldSuggester).onChange((async e=>{this.plugin.settings.fieldSuggester=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("FILETYPE_NAME")).setDesc(fragWithHTML(t$d("FILETYPE_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.experimentalFileType).onChange((async e=>{this.plugin.settings.experimentalFileType=e,this.plugin.experimentalFileTypeDisplayToggle(e),this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("FILETAG_NAME")).setDesc(fragWithHTML(t$d("FILETAG_DESC"))).addText((e=>e.setPlaceholder(t$d("INSERT_EMOJI")).setValue(this.plugin.settings.experimentalFileTag).onChange((async e=>{this.plugin.settings.experimentalFileTag=e,this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("LIVEPREVIEW_NAME")).setDesc(fragWithHTML(t$d("LIVEPREVIEW_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.experimentalLivePreview).onChange((async e=>{this.plugin.settings.experimentalLivePreview=e,this.applySettingsUpdate()})))),this.containerEl.createEl("h2",{text:t$d("TASKBONE_HEAD")}),this.containerEl.createEl("p",{text:t$d("TASKBONE_DESC")}),new obsidian_module.Setting(t).setName(t$d("TASKBONE_ENABLE_NAME")).setDesc(fragWithHTML(t$d("TASKBONE_ENABLE_DESC"))).addToggle((e=>e.setValue(this.plugin.settings.taskboneEnabled).onChange((async e=>{if(u.setDisabled(!e),this.plugin.settings.taskboneEnabled=e,""===this.plugin.settings.taskboneAPIkey){const e=await this.plugin.taskbone.initialize(!1);e&&u.setValue(e)}this.applySettingsUpdate()})))),new obsidian_module.Setting(t).setName(t$d("TASKBONE_APIKEY_NAME")).setDesc(fragWithHTML(t$d("TASKBONE_APIKEY_DESC"))).addText((e=>{u=e,u.setValue(this.plugin.settings.taskboneAPIkey).onChange((async e=>{this.plugin.settings.taskboneAPIkey=e,this.applySettingsUpdate()})).setDisabled(!this.plugin.settings.taskboneEnabled)}));const g=null===(e=this.plugin.scriptEngine.getListofScripts())||void 0===e?void 0:e.map((e=>this.plugin.scriptEngine.getScriptName(e)));if(Object.keys(this.plugin.settings.scriptEngineSettings).length>0&&g){const e=(e,t)=>{const A=this.plugin.settings.scriptEngineSettings[e][t];return"object"==typeof A?A.height:null},A=(e,t)=>{const A=this.plugin.settings.scriptEngineSettings[e][t];return"object"==typeof A?A.value:A},i=(e,t,A)=>{"object"==typeof this.plugin.settings.scriptEngineSettings[e][t]?this.plugin.settings.scriptEngineSettings[e][t].value=A:this.plugin.settings.scriptEngineSettings[e][t]=A},n=(e,n,a)=>{new obsidian_module.Setting(t).setName(n).setDesc(fragWithHTML(null!=a?a:"")).addToggle((t=>t.setValue(A(e,n)).onChange((async t=>{i(e,n,t),this.applySettingsUpdate()}))))},a=(n,a,r,s)=>{s&&"[object Array]"===Object.prototype.toString.call(s)&&s.length>0?new obsidian_module.Setting(t).setName(a).setDesc(fragWithHTML(null!=r?r:"")).addDropdown((e=>{s.forEach((t=>e.addOption(t.toString(),t.toString()))),e.setValue(A(n,a)).onChange((async e=>{i(n,a,e),this.applySettingsUpdate()}))})):e(n,a)?new obsidian_module.Setting(t).setName(a).setDesc(fragWithHTML(null!=r?r:"")).addTextArea((t=>{t.inputEl.style.minHeight=e(n,a),t.inputEl.style.minWidth="400px",t.setValue(A(n,a)).onChange((async e=>{i(n,a,e),this.applySettingsUpdate()}))})):new obsidian_module.Setting(t).setName(a).setDesc(fragWithHTML(null!=r?r:"")).addText((e=>e.setValue(A(n,a)).onChange((async e=>{i(n,a,e),this.applySettingsUpdate()}))))},r=(e,n,a)=>{new obsidian_module.Setting(t).setName(n).setDesc(fragWithHTML(null!=a?a:"")).addText((t=>t.setPlaceholder("Enter a number").setValue(A(e,n).toString()).onChange((async a=>{const r=parseFloat(a);isNaN(r)&&""!==a?t.setValue(A(e,n).toString()):(i(e,n,isNaN(r)?0:r),this.applySettingsUpdate())}))))};this.containerEl.createEl("h1",{text:t$d("SCRIPT_SETTINGS_HEAD")}),Object.keys(this.plugin.settings.scriptEngineSettings).filter((e=>g.contains(e))).forEach((e=>{const t=this.plugin.settings.scriptEngineSettings[e],A=Object.values(t);0===A.length||A.length>0&&0===A.map((e=>e.hidden?0:1)).reduce(((e,t)=>e+t))||(this.containerEl.createEl("h3",{text:e}),Object.keys(t).forEach((A=>{var i;const s=t[A];switch(typeof(null!==(i=s.value)&&void 0!==i?i:s)){case"boolean":s.hidden||n(e,A,s.description);break;case"string":s.hidden||a(e,A,s.description,s.valueset);break;case"number":s.hidden||r(e,A,s.description)}})))}))}}}var openDialogAction;!function(e){e[e.openFile=0]="openFile",e[e.insertLinkToDrawing=1]="insertLinkToDrawing"}(openDialogAction||(openDialogAction={}));class OpenFileDialog extends obsidian_module.FuzzySuggestModal{constructor(e,t){super(e),this.app=e,this.action=openDialogAction.openFile,this.plugin=t,this.onNewPane=!1,this.limit=20,this.setInstructions([{command:t$d("TYPE_FILENAME"),purpose:""}]),this.inputEl.onkeyup=e=>{"Enter"==e.key&&this.action==openDialogAction.openFile&&this.containerEl.innerText.includes(EMPTY_MESSAGE)&&(this.plugin.createAndOpenDrawing(`${this.plugin.settings.folder}/${this.inputEl.value}.excalidraw.md`,this.onNewPane?"new-pane":"active-pane"),this.close())}}getItems(){return(this.app.vault.getFiles()||[]).filter((e=>this.plugin.isExcalidrawFile(e)))}getItemText(e){return e.path}onChooseItem(e){switch(this.action){case openDialogAction.openFile:this.plugin.openDrawing(e,this.onNewPane?"new-pane":"active-pane",!0);break;case openDialogAction.insertLinkToDrawing:this.plugin.embedDrawing(e)}}start(e,t){switch(this.action=e,this.onNewPane=t,e){case openDialogAction.openFile:this.emptyStateText=EMPTY_MESSAGE,this.setPlaceholder(t$d("SELECT_FILE_OR_TYPE_NEW"));break;case openDialogAction.insertLinkToDrawing:this.emptyStateText=t$d("NO_MATCH"),this.setPlaceholder(t$d("SELECT_TO_EMBED"))}this.open()}}class InsertLinkDialog extends obsidian_module.FuzzySuggestModal{constructor(e){super(e),this.app=e,this.limit=20,this.setInstructions([{command:t$d("SELECT_FILE"),purpose:""}]),this.setPlaceholder(t$d("SELECT_FILE_TO_LINK")),this.emptyStateText=t$d("NO_MATCH")}getItems(){return this.app.metadataCache.getLinkSuggestions().filter((e=>!e.path.match(REG_LINKINDEX_INVALIDCHARS)))}getItemText(e){return e.path+(e.alias?`|${e.alias}`:"")}onChooseItem(e){let t=e.path;e.file&&(t=this.app.metadataCache.fileToLinktext(e.file,this.drawingPath,!0)),this.addText(`[[${t+(e.alias?`|${e.alias}`:"")}]]`)}start(e,t){this.addText=t,this.drawingPath=e,this.open()}}class InsertImageDialog extends obsidian_module.FuzzySuggestModal{constructor(e){super(e.app),this.plugin=e,this.app=e.app,this.limit=20,this.setInstructions([{command:t$d("SELECT_FILE_WITH_OPTION_TO_SCALE"),purpose:""}]),this.setPlaceholder(t$d("SELECT_DRAWING")),this.emptyStateText=t$d("NO_MATCH"),this.inputEl.onkeyup=e=>{"Enter"===e.key&&scaleToFullsizeModifier(e)&&this.chooser.values&&(this.onChooseItem(this.chooser.values[this.chooser.selectedItem].item,new KeyboardEvent("keypress",{shiftKey:!0,metaKey:!(DEVICE.isIOS||DEVICE.isMacOS),ctrlKey:DEVICE.isIOS||DEVICE.isMacOS})),this.close())}}getItems(){return(this.app.vault.getFiles()||[]).filter((e=>(IMAGE_TYPES.contains(e.extension)||this.plugin.isExcalidrawFile(e))&&!e.path.match(REG_LINKINDEX_INVALIDCHARS)))}getItemText(e){return e.path}onChooseItem(e,t){const A=this.plugin.ea.getAPI(this.view);A.canvas.theme=this.view.excalidrawAPI.getAppState().theme;const i=scaleToFullsizeModifier(t);(async()=>{await A.addImage(0,0,e,!i),A.addElementsToView(!0,!0,!0)})()}start(e){this.view=e,this.open()}}class ImportSVGDialog extends obsidian_module.FuzzySuggestModal{constructor(e){super(e.app),this.plugin=e,this.app=e.app,this.limit=20,this.setInstructions([{command:t$d("SELECT_FILE"),purpose:""}]),this.setPlaceholder(t$d("SELECT_DRAWING")),this.emptyStateText=t$d("NO_MATCH")}getItems(){return(this.app.vault.getFiles()||[]).filter((e=>"svg"===e.extension&&!e.path.match(REG_LINKINDEX_INVALIDCHARS)))}getItemText(e){return e.path}async onChooseItem(e,t){if(!e)return;const A=this.plugin.ea;A.reset(),A.setView(this.view);const i=await app.vault.read(e);i&&""!==i&&(A.importSVG(i),A.addElementsToView(!0,!0,!0,!0))}start(e){this.view=e,this.open()}}class InsertMDDialog extends obsidian_module.FuzzySuggestModal{constructor(e){super(e.app),this.plugin=e,this.app=e.app,this.limit=20,this.setInstructions([{command:t$d("SELECT_FILE"),purpose:""}]),this.setPlaceholder(t$d("SELECT_MD")),this.emptyStateText=t$d("NO_MATCH")}getItems(){return(this.app.vault.getFiles()||[]).filter((e=>"md"===e.extension&&!this.plugin.isExcalidrawFile(e)))}getItemText(e){return e.path}onChooseItem(e){const t=this.plugin.ea;t.reset(),t.setView(this.view),(async()=>{await t.addImage(0,0,e),t.addElementsToView(!0,!1,!0)})()}start(e){this.view=e,this.open()}}function around(e,t){const A=Object.keys(t).map((A=>around1(e,A,t[A])));return 1===A.length?A[0]:function(){A.forEach((e=>e()))}}function around1(e,t,A){const i=e[t],n=e.hasOwnProperty(t);let a=A(i);return i&&Object.setPrototypeOf(a,i),Object.setPrototypeOf(r,a),e[t]=r,s;function r(...A){return a===i&&e[t]===r&&s(),a.apply(this,A)}function s(){e[t]===r&&(n?e[t]=i:delete e[t]),a!==i&&(a=i,Object.setPrototypeOf(r,i||Function))}}let plugin,vault,metadataCache;const getDefaultWidth=e=>{const t=parseInt(e.settings.width);return isNaN(t)||0===t||null===t?"400":e.settings.width},initializeMarkdownPostProcessor=e=>{plugin=e,vault=e.app.vault,metadataCache=e.app.metadataCache},getIMG=async(e,t=!1)=>{var A;let i=e.file;if(!e.file){const t=vault.getAbstractFileByPath(null===(A=e.fname)||void 0===A?void 0:A.split("#")[0]);if(!(t&&t instanceof obsidian_module.TFile))return null;i=t}const n=getEmbeddedFilenameParts(e.fname);e.style=e.style.replaceAll(" ","-");const a=hasExportTheme(plugin,i)?getExportTheme(plugin,i,"light"):void 0,r={withBackground:getWithBackground(plugin,i),withTheme:!!a||plugin.settings.exportWithTheme},s=createEl("img");let o=`max-width:${e.fwidth}${e.fwidth.match(/\d$/)?"px":""}; `;e.fheight&&(o+=`height:${e.fheight}px;`),t||s.setAttribute("style",o),s.addClass(e.style),s.addClass("excalidraw-embedded-img");const l=null!=a?a:plugin.settings.previewMatchObsidianTheme?isObsidianThemeDark()?"dark":"light":plugin.settings.exportWithTheme?void 0:"light";l&&(r.withTheme=!0);const c=new EmbeddedFilesLoader(plugin,l?"dark"===l:void 0),d=imageCache.isReady();if(!plugin.settings.displaySVGInPreview){const t=parseInt(e.fwidth),A=t>=2400?5:t>=1800?4:t>=1200?3:t>=600?2:1,a=Object.assign(Object.assign({},n),{isDark:"dark"===l,isSVG:!1,scale:A});if(d){const e=await imageCache.getImageFromCache(a);if(e)return s.src=e,s}const o=n.hasGroupref||n.hasFrameref?void 0:await getQuickImagePreview(plugin,i.path,"png"),h=null!=o?o:await createPNG(n.hasGroupref||n.hasFrameref?n.filepath+n.linkpartReference:i.path,A,r,c,l,null,null,[],plugin,0);return h?(s.src=URL.createObjectURL(h),d&&imageCache.addImageToCache(a,s.src,h),s):null}const h=Object.assign(Object.assign({},n),{isDark:"dark"===l,isSVG:!0,scale:1});if(d){const e=await imageCache.getImageFromCache(h);if(e)return s.setAttribute("src",e),s}let u=null;const g=document.createElement("div");if(!n.hasBlockref&&!n.hasSectionref){const e=await getQuickImagePreview(plugin,i.path,"svg");if(e){g.innerHTML=e;const t=g.firstChild;if(t instanceof SVGSVGElement&&(u=t),u)return addSVGToImgSrc(s,u,d,h)}}const p=(await createSVG(n.hasGroupref||n.hasBlockref||n.hasSectionref||n.hasFrameref?n.filepath+n.linkpartReference:i.path,!0,r,c,l,null,null,[],plugin,0,getExportPadding(plugin,i))).outerHTML;g.innerHTML=p;const m=g.firstChild;return m instanceof SVGSVGElement&&(u=m),u?(u=embedFontsInSVG(u,plugin),u.removeAttribute("width"),u.removeAttribute("height"),addSVGToImgSrc(s,u,d,h)):null},addSVGToImgSrc=(e,t,A,i)=>{const n=(new XMLSerializer).serializeToString(t),a=new Blob([n],{type:"image/svg+xml"}),r=URL.createObjectURL(a);return e.setAttribute("src",r),A&&imageCache.addImageToCache(i,r,a),e},createImgElement=async(e,t=!1)=>{const A=await getIMG(e,t);let i;A.setAttribute("fileSource",e.fname),e.fwidth&&A.setAttribute("w",e.fwidth),e.fheight&&A.setAttribute("h",e.fheight),A.setAttribute("draggable","false"),A.setAttribute("onCanvas",t?"true":"false");const n=e=>{if(e.target instanceof Element&&"img"!=e.target.tagName.toLowerCase())return;const t=A.getAttribute("fileSource");if(t){const A=t.match(/([^#]*)(.*)/);if(!A)return;plugin.openDrawing(vault.getAbstractFileByPath(A[1]),linkClickModifierType(e),!0,A[2])}};let a;return A.addEventListener("pointermove",(e=>{i&&(Math.abs(e.screenX-a.screenX)>10||Math.abs(e.screenY-a.screenY)>10)&&(clearTimeout(i),i=null)})),A.addEventListener("pointerdown",(e=>{var t;(null===(t=null==A?void 0:A.parentElement)||void 0===t?void 0:t.hasClass("canvas-node-content"))||(i=setTimeout((()=>n(e)),500),a=e)})),A.addEventListener("pointerup",(()=>{i&&clearTimeout(i),i=null})),A.addEventListener("dblclick",n),A.addEventListener(RERENDER_EVENT,(async e=>{e.stopPropagation();const t=A.parentElement,i=A.style.maxWidth,n=A.style.maxHeight,a=A.getAttribute("fileSource"),r="true"===A.getAttribute("onCanvas"),s=await createImgElement({fname:a,fwidth:A.getAttribute("w"),fheight:A.getAttribute("h"),style:A.getAttribute("class")},r);t.empty(),r||(s.style.maxHeight=n,s.style.maxWidth=i),s.setAttribute("fileSource",a),t.append(s)})),A},createImageDiv=async(e,t=!1)=>{const A=await createImgElement(e,t);return createDiv(e.style,(e=>e.append(A)))},processReadingMode=async(e,t)=>{var A;for(const i of e){const e=null===(A=i.getAttribute("src"))||void 0===A?void 0:A.split("#")[0];if(!e)continue;const n=metadataCache.getFirstLinkpathDest(e,t.sourcePath);if(n&&n instanceof obsidian_module.TFile&&plugin.isExcalidrawFile(n)){if(isTextOnlyEmbed(i))continue;i.parentElement.replaceChild(await processInternalEmbed(i,n),i)}}},processInternalEmbed=async(e,t)=>{const A={fname:"",fheight:"",fwidth:"",style:""},i=e.getAttribute("src");if(!i)return;e.removeClass("markdown-embed"),e.removeClass("inline-embed"),e.addClass("media-embed"),e.addClass("image-embed"),A.fwidth=e.getAttribute("width")?e.getAttribute("width"):getDefaultWidth(plugin),A.fheight=e.getAttribute("height");let n=e.getAttribute("alt");A.style="excalidraw-svg",processAltText(i.split("#")[0],n,A);const a=getEmbeddedFilenameParts(i);return A.fname=(null==t?void 0:t.path)+(a.hasBlockref||a.hasSectionref?a.linkpartReference:""),A.file=t,await createImageDiv(A)},processAltText=(e,t,A)=>{var i,n;if(t&&!t.startsWith(e)){const a=t.match(/[^\|\d]*\|?((\d*%?)x?(\d*%?))?\|?(.*)/);A.fwidth=null!==(i=a[2])&&void 0!==i?i:A.fwidth,A.fheight=null!==(n=a[3])&&void 0!==n?n:A.fheight,a[4]&&!a[4].startsWith(e)&&(A.style=`excalidraw-svg-${a[4]}`),a[4]&&""!==a[4]||a[2]&&""!==a[2]||!a[0]||""===a[0]||(A.style=`excalidraw-svg-${a[0]}`)}},isTextOnlyEmbed=e=>{const t=e.getAttribute("src");if(!t)return!0;const A=getEmbeddedFilenameParts(t);return!(A.hasArearef||A.hasGroupref||A.hasFrameref)&&(A.hasBlockref||A.hasSectionref)},tmpObsidianWYSIWYG=async(e,t)=>{const A=app.vault.getAbstractFileByPath(t.sourcePath);if(!(A instanceof obsidian_module.TFile))return;if(!plugin.isExcalidrawFile(A))return;if(t.remainingNestLevel<4)return;const i=t.containerEl;let n=i;for(;!n.hasClass("dataview")&&!n.hasClass("cm-preview-code-block")&&!n.hasClass("cm-embed-block")&&!n.hasClass("internal-embed")&&!n.hasClass("markdown-reading-view")&&!n.hasClass("markdown-embed")&&n.parentElement;)n=n.parentElement;if(n.hasClass("dataview")||n.hasClass("cm-preview-code-block")||n.hasClass("cm-embed-block"))return;const a={fname:t.sourcePath,fheight:"",fwidth:getDefaultWidth(plugin),style:"excalidraw-svg"};a.file=A;const r=n.hasClass("markdown-embed"),s=n.hasClass("markdown-reading-view");if(!n.hasClass("internal-embed")&&(r||s)){const t=Boolean(e.querySelector(".frontmatter"));if(e.empty(),!t)return void(e.parentElement===i&&i.removeChild(e));n.empty();const A=n.hasClass("canvas-node-content"),s=await createImageDiv(a,A);return r?(n.removeClass("markdown-embed"),n.removeClass("inline-embed"),n.addClass("media-embed"),n.addClass("image-embed"),!A&&s.firstChild instanceof HTMLElement&&(s.firstChild.style.maxHeight="100%",s.firstChild.style.maxWidth=null),void n.appendChild(s.firstChild)):void n.appendChild(s)}if(isTextOnlyEmbed(n))return;if(e.empty(),n.hasAttribute("ready"))return;n.setAttribute("ready",""),n.empty();const o=await processInternalEmbed(n,A);n.appendChild(o);let l=null;const c=new MutationObserver((e=>{var t;["alt","width","height"].contains(null===(t=e[0])||void 0===t?void 0:t.attributeName)&&(l&&clearTimeout(l),l=setTimeout((async()=>{l=null,n.empty();const e=await processInternalEmbed(n,A);n.appendChild(e)}),500))}));c.observe(n,{attributes:!0})},markdownPostProcessor=async(e,t)=>{var A;const i=e.querySelectorAll(".internal-embed");0!==i.length?Boolean(null===(A=t.frontmatter)||void 0===A?void 0:A.hasOwnProperty("excalidraw-plugin"))?e.style.display="none":await processReadingMode(i,t):tmpObsidianWYSIWYG(e,t)},hoverEvent=e=>{e.linktext?(plugin.hover.linkText=e.linktext,plugin.hover.sourcePath=e.sourcePath):plugin.hover.linkText=null},observer=new MutationObserver((async e=>{if(0==e.length)return;if(!plugin.hover.linkText)return;const t=metadataCache.getFirstLinkpathDest(plugin.hover.linkText,plugin.hover.sourcePath?plugin.hover.sourcePath:"");if(!t)return;if(!(t instanceof obsidian_module.TFile))return;if("excalidraw"!==t.extension)return;const A=getIMGFilename(t.path,"svg"),i=vault.getAbstractFileByPath(A);if(i&&i instanceof obsidian_module.TFile)return;const n=getIMGFilename(t.path,"png"),a=vault.getAbstractFileByPath(n);if(a&&a instanceof obsidian_module.TFile)return;if(!plugin.hover.linkText)return;if(1!=e.length)return;if(1!=e[0].addedNodes.length)return;if("popover hover-popover file-embed is-loaded"!=!e[0].addedNodes[0].classNames)return;const r=e[0].addedNodes[0];r.empty();const s=await getIMG({file:t,fname:t.path,fwidth:"300",fheight:null,style:"excalidraw-svg"}),o=createDiv("",(async e=>{e.appendChild(s),e.setAttribute("src",t.path),e.onClickEvent((t=>{t.stopImmediatePropagation();const A=e.getAttribute("src");A&&plugin.openDrawing(vault.getAbstractFileByPath(A),linkClickModifierType(t))}))}));r.appendChild(o)})),EXCALIDRAW_AUTOMATE_INFO=[{field:"plugin",code:null,desc:"The ExcalidrawPlugin object",after:""},{field:"elementsDict",code:null,desc:"The {} dictionary object, contains the ExcalidrawElements currently edited in Automate indexed by el.id",after:'[""]'},{field:"imagesDict",code:null,desc:"the images files including DataURL, indexed by fileId",after:'[""]'},{field:"style.strokeColor",code:"[string]",desc:"A valid css color. See W3 School Colors for more.",after:""},{field:"style.backgroundColor",code:"[string]",desc:"A valid css color. See W3 School Colors for more.",after:""},{field:"style.angle",code:"[number]",desc:"Rotation of the object in radian",after:""},{field:"style.fillStyle",code:"[string]",desc:"'hachure' | 'cross-hatch' | 'solid'",after:""},{field:"style.strokeWidth",code:"[number]",desc:null,after:""},{field:"style.strokeStyle",code:"[string]",desc:"'solid' | 'dashed' | 'dotted'",after:""},{field:"style.roughness",code:"[number]",desc:"0:Architect\n1:Artist\n2:Cartoonist",after:""},{field:"style.opacity",code:"[number]",desc:"100: Fully opaque\n0: Fully transparent",after:""},{field:"style.roundness",code:"[null | { type: RoundnessType; value?: number };]",desc:"set to null for 'sharp', else the stroke will be 'round'
type: 1==LEGACY,
2==PROPORTIONAL RADIUS,
3==ADAPTIVE RADIUS, value: adaptive factor defaults to 32",after:""},{field:"style.fontFamily",code:"[number]",desc:"1: Virgil, 2:Helvetica, 3:Cascadia, 4:LocalFont",after:""},{field:"style.fontSize",code:"[number]",desc:null,after:""},{field:"style.textAlign",code:"[string]",desc:"'left' | 'right' | 'center'",after:""},{field:"style.verticalAlign",code:"[string]",desc:"For future use, has no effect currently; 'top' | 'bottom' | 'middle'",after:""},{field:"style.startArrowHead",code:"[string]",desc:"'triangle' | 'dot' | 'arrow' | 'bar' | null",after:""},{field:"style.endArrowHead",code:"[string]",desc:"'triangle' | 'dot' | 'arrow' | 'bar' | null",after:""},{field:"canvas.theme",code:"[string]",desc:"'dark' | 'light'",after:""},{field:"canvas.viewBackgroundColor",code:"[string]",desc:"A valid css color.\nSee W3 School Colors for more.",after:""},{field:"canvas.gridSize",code:"[number]",desc:null,after:""},{field:"setStrokeSharpness",code:"setStrokeSharpness(sharpness: number): void;",desc:"Set ea.style.roundness. 0: is the legacy value, 3: is the current default value, null is sharp",after:""},{field:"addToGroup",code:"addToGroup(objectIds: []): string;",desc:null,after:""},{field:"toClipboard",code:"toClipboard(templatePath?: string): void;",desc:"Copies current elements using template to clipboard, ready to be pasted into an excalidraw canvas",after:""},{field:"getSceneFromFile",code:"async getSceneFromFile(file: TFile): Promise<{elements: ExcalidrawElement[]; appState: AppState;}>;",desc:"returns the elements and appState from a file, if the file is not an excalidraw file, it will return null",after:""},{field:"getElements",code:"getElements(): ExcalidrawElement[];",desc:"Get all elements from ExcalidrawAutomate elementsDict",after:""},{field:"getElement",code:"getElement(id: string): ExcalidrawElement;",desc:"Get single element from ExcalidrawAutomate elementsDict",after:""},{field:"create",code:'create(params?: {filename?: string, foldername?: string, templatePath?: string, onNewPane?: boolean, frontmatterKeys?: { "excalidraw-plugin"?: "raw" | "parsed", "excalidraw-link-prefix"?: string, "excalidraw-link-brackets"?: boolean, "excalidraw-url-prefix"?: string,},}): Promise;',desc:"Create a drawing and save it to filename.\nIf filename is null: default filename as defined in Excalidraw settings.\nIf folder is null: default folder as defined in Excalidraw settings\n",after:""},{field:"createSVG",code:"createSVG(templatePath?: string, embedFont?: boolean, exportSettings?: ExportSettings, loader?: EmbeddedFilesLoader, theme?: string,): Promise;",desc:"Use ExcalidrawAutomate.getExportSettings(boolean,boolean) to create an ExportSettings object.\nUse ExcalidrawAutomate.getEmbeddedFilesLoader(boolean?) to create an EmbeddedFilesLoader object.",after:""},{field:"createPNG",code:"createPNG(templatePath?: string, scale?: number, exportSettings?: ExportSettings, loader?: EmbeddedFilesLoader, theme?: string,): Promise;",desc:"Use ExcalidrawAutomate.getExportSettings(boolean,boolean) to create an ExportSettings object.\nUse ExcalidrawAutomate.getEmbeddedFilesLoader(boolean?) to create an EmbeddedFilesLoader object.",after:""},{field:"wrapText",code:"wrapText(text: string, lineLen: number): string;",desc:null,after:""},{field:"addRect",code:"addRect(topX: number, topY: number, width: number, height: number): string;",desc:null,after:""},{field:"addDiamond",code:"addDiamond(topX: number, topY: number, width: number, height: number): string;",desc:null,after:""},{field:"addEllipse",code:"addEllipse(topX: number, topY: number, width: number, height: number): string;",desc:null,after:""},{field:"addBlob",code:"addBlob(topX: number, topY: number, width: number, height: number): string;",desc:null,after:""},{field:"refreshTextElementSize",code:"refreshTextElementSize(id: string);",desc:"Refreshes the size of the text element. Intended to be used when you copyViewElementsToEAforEditing() and then change the text in a text element and want to update the size of the text element to fit the modifid contents.",after:""},{field:"addText",code:'addText(topX: number, topY: number, text: string, formatting?: {wrapAt?: number; width?: number; height?: number; textAlign?: "left" | "center" | "right"; textVerticalAlign: "top" | "middle" | "bottom"; box?: boolean | "box" | "blob" | "ellipse" | "diamond"; boxPadding?: number; boxStrokeColor?: string;}, id?: string,): string;',desc:"If box is !null, then text will be boxed\nThe function returns the id of the TextElement. If the text element is boxed i.e. it is a sticky note, then the id of the container object",after:""},{field:"addLine",code:"addLine(points: [[x: number, y: number]]): string;",desc:null,after:""},{field:"addArrow",code:"addArrow(points: [[x: number, y: number]], formatting?: { startArrowHead?: string; endArrowHead?: string; startObjectId?: string; endObjectId?: string;},): string;",desc:null,after:""},{field:"addImage",code:"addImage(topX: number, topY: number, imageFile: TFile, scale?: boolean, anchor?: boolean): Promise;",desc:"set scale to false if you want to embed the image at 100% of its original size. Default is true which will insert a scaled image. anchor will only be evaluated if scale is false. anchor true will add |100% to the end of the filename, resulting in an image that will always pop back to 100% when the source file is updated or when the Excalidraw file is reopened. ",after:""},{field:"addEmbeddable",code:"addEmbeddable(topX: number, topY: number, width: number, height: number, url?: string, file?: TFile): string;",desc:"Adds an iframe to the drawing. If url is not null then the iframe will be loaded from the url. The url maybe a markdown link to an note in the Vault or a weblink. If url is null then the iframe will be loaded from the file. Both the url and the file may not be null.",after:""},{field:"addLaTex",code:"addLaTex(topX: number, topY: number, tex: string): Promise;",desc:null,after:""},{field:"connectObjects",code:"connectObjects(objectA: string, connectionA: ConnectionPoint, objectB: string, connectionB: ConnectionPoint, formatting?: {numberOfPoints?: number; startArrowHead?: string; endArrowHead?: string; padding?: number;},): string;",desc:'type ConnectionPoint = "top" | "bottom" | "left" | "right" | null\nWhen null is passed as ConnectionPoint then Excalidraw will automatically decide\nnumberOfPoints is the number of points on the line. Default is 0 i.e. line will only have a start and end point.\nArrowHead: "triangle"|"dot"|"arrow"|"bar"|null',after:""},{field:"addLabelToLine",code:"addLabelToLine(lineId: string, label: string): string;",desc:"Adds a text label to a line or arrow. Currently only works with a simple straight 2-point (start & end) line",after:""},{field:"clear",code:"clear(): void;",desc:"Clears elementsDict and imagesDict only",after:""},{field:"reset",code:"reset(): void;",desc:"clear() + reset all style values to default",after:""},{field:"isExcalidrawFile",code:"isExcalidrawFile(f: TFile): boolean;",desc:"Returns true if MD file is an Excalidraw file",after:""},{field:"targetView",code:"targetView: ExcalidrawView;",desc:"The Obsidian view currently edited",after:""},{field:"setView",code:'setView(view: ExcalidrawView | "first" | "active"): ExcalidrawView;',desc:null,after:""},{field:"getExcalidrawAPI",code:"getExcalidrawAPI(): any;",desc:"Excalidraw API",after:""},{field:"getViewElements",code:"getViewElements(): ExcalidrawElement[];",desc:"Get elements in View",after:""},{field:"deleteViewElements",code:"deleteViewElements(el: ExcalidrawElement[]): boolean;",desc:null,after:""},{field:"getViewSelectedElement",code:"getViewSelectedElement(): ExcalidrawElement;",desc:"Get the selected element in the view, if more are selected, get the first",after:""},{field:"getViewSelectedElements",code:"getViewSelectedElements(): ExcalidrawElement[];",desc:null,after:""},{field:"getViewFileForImageElement",code:"getViewFileForImageElement(el: ExcalidrawElement): TFile | null;",desc:"Returns the TFile file handle for the image element",after:""},{field:"copyViewElementsToEAforEditing",code:"copyViewElementsToEAforEditing(elements: ExcalidrawElement[]): void;",desc:"Copies elements from view to elementsDict for editing",after:""},{field:"viewToggleFullScreen",code:"viewToggleFullScreen(forceViewMode?: boolean): void;",desc:null,after:""},{field:"connectObjectWithViewSelectedElement",code:"connectObjectWithViewSelectedElement(objectA: string, connectionA: ConnectionPoint, connectionB: ConnectionPoint, formatting?: {numberOfPoints?: number; startArrowHead?: string; endArrowHead?: string; padding?: number;},): boolean;",desc:"Connect an object to the selected element in the view\nSee tooltip for connectObjects for details",after:""},{field:"addElementsToView",code:"addElementsToView(repositionToCursor?: boolean, save?: boolean, newElementsOnTop?: boolean,shouldRestoreElements?: boolean,): Promise;",desc:"Adds elements from elementsDict to the current view\nrepositionToCursor: default is false\nsave: default is true\nnewElementsOnTop: default is false, i.e. the new elements get to the bottom of the stack\nnewElementsOnTop controls whether elements created with ExcalidrawAutomate are added at the bottom of the stack or the top of the stack of elements already in the view\nNote that elements copied to the view with copyViewElementsToEAforEditing retain their position in the stack of elements in the view even if modified using EA",after:""},{field:"onDropHook",code:'onDropHook(data: {ea: ExcalidrawAutomate, event: React.DragEvent, draggable: any, type: "file" | "text" | "unknown", payload: {files: TFile[], text: string,}, excalidrawFile: TFile, view: ExcalidrawView, pointerPosition: { x: number, y: number},}): boolean;',desc:"If set Excalidraw will call this function onDrop events.\nA return of true will stop the default onDrop processing in Excalidraw.\n\ndraggable is the Obsidian draggable object\nfiles is the array of dropped files\nexcalidrawFile is the file receiving the drop event\nview is the excalidraw view receiving the drop.\npointerPosition is the pointer position on canvas at the time of drop.",after:""},{field:"mostRecentMarkdownSVG",code:"mostRecentMarkdownSVG: SVGSVGElement;",desc:"Markdown renderer will drop a copy of the most recent SVG here for debugging purposes",after:""},{field:"getEmbeddedFilesLoader",code:"getEmbeddedFilesLoader(isDark?: boolean): EmbeddedFilesLoader;",desc:"Utility function to generate EmbeddedFilesLoader object",after:""},{field:"getExportSettings",code:"getExportSettings(withBackground: boolean, withTheme: boolean,): ExportSettings;",desc:"Utility function to generate ExportSettings object",after:""},{field:"getBoundingBox",code:"getBoundingBox(elements: ExcalidrawElement[]): {topX: number, topY: number, width: number, height: number,};",desc:"Gets the bounding box of elements. The bounding box is the box encapsulating all of the elements completely.",after:""},{field:"getMaximumGroups",code:"getMaximumGroups(elements: ExcalidrawElement[]): ExcalidrawElement[][];",desc:"Elements grouped by the highest level groups",after:""},{field:"getLargestElement",code:"getLargestElement(elements: ExcalidrawElement[]): ExcalidrawElement;",desc:"Gets the largest element from a group. useful when a text element is grouped with a box, and you want to connect an arrow to the box",after:""},{field:"intersectElementWithLine",code:"intersectElementWithLine(element: ExcalidrawBindableElement, a: readonly [number, number], b: readonly [number, number], gap?: number,): Point[];",desc:"If gap is given, the element is inflated by this value.\nReturns 2 or 0 intersection points between line going through `a` and `b` and the `element`, in ascending order of distance from `a`.",after:""},{field:"getCommonGroupForElements",code:"getCommonGroupForElements(elements: ExcalidrawElement[]): string;",desc:"Gets the groupId for the group that contains all the elements, or null if such a group does not exist",after:""},{field:"getElementsInTheSameGroupWithElement",code:"getElementsInTheSameGroupWithElement(element: ExcalidrawElement, elements: ExcalidrawElement[]): ExcalidrawElement[];",desc:"Gets all the elements from elements[] that share one or more groupIds with element.",after:""},{field:"activeScript",code:"activeScript: string;",desc:"Mandatory to set before calling the get and set ScriptSettings functions. Set automatically by the ScriptEngine\nSee for more details: Script Engine Help",after:""},{field:"getScriptSettings",code:"getScriptSettings(): {};",desc:"Returns script settings. Saves settings in plugin settings, under the activeScript key. See for more details: Script Engine Help",after:""},{field:"setScriptSettings",code:"setScriptSettings(settings: any): Promise;",desc:"Sets script settings.\nSee for more details: Script Engine Help",after:""},{field:"openFileInNewOrAdjacentLeaf",code:"openFileInNewOrAdjacentLeaf(file: TFile): WorkspaceLeaf;",desc:"Open a file in a new workspaceleaf or reuse an existing adjacent leaf depending on Excalidraw Plugin Settings",after:""},{field:"measureText",code:"measureText(text: string): { width: number; height: number };",desc:"Measures text size based on current style settings",after:""},{field:"verifyMinimumPluginVersion",code:"verifyMinimumPluginVersion(requiredVersion: string): boolean;",desc:'Returns true if plugin version is >= than required\nrecommended use:\nif(!ea.verifyMinimumPluginVersion || !ea.verifyMinimumPluginVersion("1.5.20")) {new Notice("message");return;}',after:""},{field:"selectElementsInView",code:"selectElementsInView(elements: ExcalidrawElement[] | string[]):void;",desc:"You can supply a list of Excalidraw Elements or the string IDs of those elements. The elements provided will be set as selected in the targetView.",after:""},{field:"generateElementId",code:"generateElementId(): string;",desc:"Returns an 8 character long random id",after:""},{field:"cloneElement",code:"cloneElement(element: ExcalidrawElement): ExcalidrawElement;",desc:"Returns a clone of the element with a new element id",after:""},{field:"moveViewElementToZIndex",code:"moveViewElementToZIndex(elementId:number, newZIndex:number): void;",desc:"Moves the element to a specific position in the z-index",after:""},{field:"hexStringToRgb",code:"hexStringToRgb(color: string):number[];",desc:"Converts a HEX color to an RGB number array. #FF0000 to [255,0,0]",after:""},{field:"rgbToHexString",code:"rgbToHexString(color: number[]):string;",desc:"Converts an RGB number array to a HEX string. [255,0,0] to #FF0000",after:""},{field:"hslToRgb",code:"hslToRgb(color: number[]):number[];",desc:"Converts an HSL number array to an RGB number array. [0,100,50] to [255,0,0]",after:""},{field:"rgbToHsl",code:"rgbToHsl(color:number[]):number[];",desc:"Converts an RGB number array to an HSL number array. [255,0,0] to [0,100,50]",after:""},{field:"colorNameToHex",code:"colorNameToHex(color:string):string;",desc:"Converts a CSS color name to its HEX color equivalent. 'White' to #FFFFFF",after:""},{field:"obsidian",code:"obsidian",desc:"Access functions and objects available on the Obsidian Module",after:""},{field:"getAttachmentFilepath",code:"async getAttachmentFilepath(filename: string): Promise",desc:"This asynchronous function should be awaited. It retrieves the filepath to a new file, taking into account the attachments preference settings in Obsidian. If the attachment folder doesn't exist, it creates it. The function returns the complete path to the file. If the provided filename already exists, the function will append '_[number]' before the extension to generate a unique filename.",after:""},{field:"setViewModeEnabled",code:"setViewModeEnabled(enabled: boolean): void;",desc:"Sets Excalidraw in the targetView to view-mode",after:""},{field:"viewUpdateScene",code:"viewUpdateScene(scene:{elements?:ExcalidrawElement[],appState?: AppState,files?: BinaryFileData,commitToHistory?: boolean,},restore:boolean=false):void",desc:"Calls the ExcalidrawAPI updateScene function for the targetView. When restore=true, excalidraw will try to correct errors in the scene such as setting default values to missing element properties.",after:""},{field:"viewZoomToElements",code:"viewZoomToElements(selectElements: boolean,elements: ExcalidrawElement[]):void",desc:"Zoom tarteView to fit elements provided as input. elements === [] will zoom to fit the entire scene. SelectElements toggles whether the elements should be in a selected state at the end of the operation.",after:""}],EXCALIDRAW_SCRIPTENGINE_INFO=[{field:"inputPrompt",code:"inputPrompt: (header: string, placeholder?: string, value?: string, buttons?: {caption:string, tooltip?:string, action:Function}[], lines?: number, displayEditorButtons?: boolean, customComponents?: (container: HTMLElement) => void, blockPointerInputOutsideModal?: boolean);",desc:"Opens a prompt that asks for an input.\nReturns a string with the input.\nYou need to await the result of inputPrompt.\nEditor buttons are text editing buttons like delete, enter, allcaps - these are only displayed if lines is greater than 1 \nCustom components are components that you can add to the prompt. These will be displayed between the text input area and the buttons.\nblockPointerInputOutsideModal will block pointer input outside the modal. This is useful if you want to prevent the user accidently closing the modal or interacting with the excalidraw canvas while the prompt is open.\nbuttons.action(input: string) => string\nThe button action function will receive the actual input string. If action returns null, input will be unchanged. If action returns a string, input will receive that value when the promise is resolved. example:\nlet fileType = '';\nconst filename = await utils.inputPrompt (\n 'Filename',\n '',\n '',\n, [\n {\n caption: 'Markdown',\n action: ()=>{fileType='md';return;}\n },\n {\n caption: 'Excalidraw',\n action: ()=>{fileType='ex';return;}\n }\n ]\n);",after:""},{field:"suggester",code:"suggester: (displayItems: string[], items: any[], hint?: string, instructions?:Instruction[]);",desc:"Opens a suggester. Displays the displayItems and returns the corresponding item from items[]\nYou need to await the result of suggester.\nIf the user cancels (ESC), suggester will return undefined\nHint and instructions are optional\n\ninterface Instruction {command: string;purpose: string;}",after:""},{field:"scriptFile",code:"scriptFile: TFile",desc:"The TFile of the currently running script",after:""}],FRONTMATTER_KEYS_INFO=[{field:"plugin",code:null,desc:"Denotes an excalidraw file. If key is not present, the file will not be recognized as an Excalidarw file. Valid values are 'parsed' and 'raw'",after:": parsed"},{field:"link-prefix",code:null,desc:"Set custom prefix to denote text element containing a valid internal link. Set to empty string if you do not want to show a prefix",after:': "📍"'},{field:"url-prefix",code:null,desc:"Set custom prefix to denote text element containing a valid external link. Set to empty string if you do not want to show a prefix",after:': "🌐"'},{field:"link-brackets",code:null,desc:"Set to true, if you want to display [[square brackets]] around the links in Text Elements",after:": true"},{field:"default-mode",code:null,desc:"Specifies how Excalidraw should open by default. Valid values are: view|zen",after:": view"},{field:"linkbutton-opacity",code:null,desc:"The opacity of the blue link button in the top right of the element overriding the respective setting in plugin settings. Valid values are between 0 and 1, where 0 means the button is transparent.",after:": 0.5"},{field:"onload-script",code:null,desc:"The value of this field will be executed as javascript code using the Script Engine environment. Use this to initiate custom actions or logic when loading your drawing.",after:': "new Notice(`Hello World!\\n\\nFile: ${ea.targetView.file.basename}`);"'},{field:"font",code:null,desc:"This key applies to Markdown Embeds. You can control the appearance of the embedded markdown file on a file by file bases by adding the this frontmatter key to your markdown document. Valid values are: Virgil|Cascadia|font_file_name.extension",after:": Virgil"},{field:"font-color",code:null,desc:"This key applies to Markdown Embeds. You can control the appearance of the embedded markdown file on a file by file bases by adding the this frontmatter key to your markdown document. Valid values are: css-color-name|#HEXcolor|any-other-html-standard-format",after:": SteelBlue"},{field:"border-color",code:null,desc:"This key applies to Markdown Embeds. You can control the appearance of the embedded markdown file on a file by file bases by adding the this frontmatter key to your markdown document. Valid values are: css-color-name|#HEXcolor|any-other-html-standard-format",after:": SteelBlue"},{field:"css",code:null,desc:'This key applies to Markdown Embeds. You can control the appearance of the embedded markdown file on a file by file bases by adding the this front matter keys to your markdown document. Valid values are: "css-filename|css snippet"',after:': ""'},{field:"export-transparent",code:null,desc:"If this key is present it will override the default excalidraw embed and export setting. true == Transparent / false == with background",after:": true"},{field:"export-dark",code:null,desc:"If this key is present it will override the default excalidraw embed and export setting. true == Dark mode / false == light mode",after:": true"},{field:"export-padding",code:null,desc:"If this key is present it will override the default excalidraw embed and export setting. This only affects both SVG and PNG export. Specify the export padding for the image.",after:": 5"},{field:"export-pngscale",code:null,desc:"If this key is present it will override the default excalidraw embed and export setting. This only affects export to PNG. Specify the export scale for the image. The typical range is between 0.5 and 5, but you can experiment with other values as well.",after:": 1"},{field:"autoexport",code:null,desc:"Override autoexport settings for this file. Valid values are\nnone\nboth\npng\nsvg",after:": png"},{field:"iframe-theme",code:null,desc:"Override iFrame theme plugin-settings for this file. 'match' will match the Excalidraw theme, 'default' will match the obsidian theme. Valid values are\ndark\nlight\nauto\ndefault",after:": auto"}];class FieldSuggester extends obsidian_module.EditorSuggest{constructor(e){super(e.app),this.getSuggestions=e=>{const t=e.query.toLowerCase();return("ea"===this.suggestType?EXCALIDRAW_AUTOMATE_INFO:"utils"===this.suggestType?EXCALIDRAW_SCRIPTENGINE_INFO:FRONTMATTER_KEYS_INFO).map((e=>e.field)).filter((e=>e.toLowerCase().includes(t)))},this.plugin=e}onTrigger(e,t,A){var i,n,a,r,s;if(this.plugin.settings.fieldSuggester){const A=t.getLine(e.line).substring(0,e.ch),o=null!==(r=null!==(n=null===(i=A.match(/^excalidraw-(.*)$/))||void 0===i?void 0:i[1])&&void 0!==n?n:null===(a=A.match(/(^ea|\Wea)\.([\w\.]*)$/))||void 0===a?void 0:a[2])&&void 0!==r?r:null===(s=A.match(/(^utils|\Wutils)\.([\w\.]*)$/))||void 0===s?void 0:s[2];if(void 0!==o)return this.suggestType=A.match(/^excalidraw-(.*)$/)?"excalidraw":A.match(/(^ea|\Wea)\.([\w\.]*)$/)?"ea":"utils",this.latestTriggerInfo={end:e,start:{ch:e.ch-o.length,line:e.line},query:o},this.latestTriggerInfo}return null}renderSuggestion(e,t){const A=e.replace("ea"===this.suggestType?"ea.":"utils"===this.suggestType?"utils.":"excalidraw-",""),i=("ea"===this.suggestType?EXCALIDRAW_AUTOMATE_INFO:"utils"===this.suggestType?EXCALIDRAW_SCRIPTENGINE_INFO:FRONTMATTER_KEYS_INFO).find((t=>t.field===e));t.createEl("b",{text:A}),t.createEl("br"),i.code&&t.createEl("code",{text:i.code}),i.desc&&t.createDiv("div",(e=>e.innerHTML=i.desc))}selectSuggestion(e){var t;const{context:A}=this;if(A){const i="ea"===this.suggestType?EXCALIDRAW_AUTOMATE_INFO:"utils"===this.suggestType?EXCALIDRAW_SCRIPTENGINE_INFO:FRONTMATTER_KEYS_INFO,n=`${e}${null===(t=i.find((t=>t.field===e)))||void 0===t?void 0:t.after}`;if(A.editor.replaceRange(n,this.latestTriggerInfo.start,this.latestTriggerInfo.end),this.latestTriggerInfo.start.ch===this.latestTriggerInfo.end.ch){const e=this.latestTriggerInfo.end;e.ch+=n.length,A.editor.setCursor(e)}}}}class FrontmatterEditor{constructor(e){this.initialized=!1,this.dataWOfrontmatter=e;const t=(e=e.replaceAll("\r\n","\n").replaceAll("\r","\n")).split(/^---(?:.|\n)*(?:^---\n)/gm);2===t.length&&(this.dataWOfrontmatter=t[1],this.frontmatterStr=e.match(/^---((?:.|\n)*)(?:^---\n)/gm)[0].replaceAll(/(^---\n|^\n)/gm,"").trim()+"\n",this.initialized=!0)}hasKey(e){if(!this.initialized)return!1;const t=new RegExp(`^${e}:`,"gm");return Boolean(this.frontmatterStr.match(t))}setKey(e,t){if(this.initialized)if(t=t.replaceAll("\r\n","\n").replaceAll("\r","\n").replaceAll(":",";").trim().split("\n").join(" "),this.hasKey(e)){const A=new RegExp(`^${e}:.*\\n(?:\\s\\s.*\\n)*`,"gm");this.frontmatterStr=this.frontmatterStr.split(A).join("\n").trim()+`\n${e}: ${t}`}else this.frontmatterStr=this.frontmatterStr.trim()+`\n${e}: ${t}`}get data(){return this.initialized?["---",this.frontmatterStr,"---",this.dataWOfrontmatter].join("\n"):this.dataWOfrontmatter}}const TASKBONE_URL="https://api.taskbone.com/",TASKBONE_OCR_FN="execute?id=60f394af-85f6-40bc-9613-5d26dc283cbb";class Taskbone{get apiKey(){return this.plugin.settings.taskboneAPIkey}constructor(e){this.plugin=e}async initialize(e=!0){var t;if(""!==this.plugin.settings.taskboneAPIkey)return;const A=await obsidian_module.requestUrl({url:`${TASKBONE_URL}users/excalidraw-obsidian/identities`,method:"post",contentType:"application/json",throw:!1});if(!A)return;const i=null===(t=A.json)||void 0===t?void 0:t.apiKey;return i&&"string"==typeof i&&(e&&await this.plugin.loadSettings(),this.plugin.settings.taskboneAPIkey=i,e&&await this.plugin.saveSettings()),i}async getTextForView(e,t){await e.forceSave(!0);const A=e.excalidrawAPI.getSceneElements().filter((t=>{var A;return"freedraw"===t.type||"image"===t.type&&!this.plugin.isExcalidrawFile(null===(A=e.excalidrawData.getFile(t.fileId))||void 0===A?void 0:A.file)}));if(0===A.length)return void new obsidian_module.Notice("Aborting OCR because there are no image or freedraw elements on the canvas.",4e3);const i=new FrontmatterEditor(e.data);if(i.hasKey("taskbone-ocr")&&!t)return void new obsidian_module.Notice("The drawing has already been processed, you will find the result in the frontmatter in markdown view mode. If you ran the command from the Obsidian Panel in Excalidraw then you can CTRL(CMD)+click the command to force the rescaning.",4e3);const n=this.plugin.ea.getBoundingBox(A),a=n.width*n.height,r=Math.sqrt(36e4/a),s=Math.sqrt(a/16e6),o=r>1?r:s>1?1/s:1,l=new EmbeddedFilesLoader(this.plugin,!1),c=await createPNG(e.file.path+"#^taskbone",o,{withBackground:!0,withTheme:!0},l,"light",null,null,[],this.plugin,0),d=await this.getTextForImage(c);d&&(i.setKey("taskbone-ocr",d),e.data=i.data,e.save(!1),window.navigator.clipboard.writeText(d),new obsidian_module.Notice("I placed the recognized in the drawing's frontmatter and onto the system clipboard."))}async getTextForImage(e){""===this.apiKey&&await this.initialize();const t={records:[{image:await blobToBase64(e)}]},A=await obsidian_module.requestUrl({url:"https://api.taskbone.com/execute?id=60f394af-85f6-40bc-9613-5d26dc283cbb",method:"post",contentType:"application/json",body:JSON.stringify(t),headers:{authorization:`Bearer ${this.apiKey}`},throw:!1}),i=null==A?void 0:A.json;return i&&200===A.status?i.records[0].text:(new obsidian_module.Notice("Something went wrong while processing your request. Please check developer console for more information"),void log(A))}}class ExcalidrawPlugin extends obsidian_module.Plugin{constructor(e,t){super(e,t),this.excalidrawFiles=new Set,this.excalidrawFileModes={},this._loaded=!1,this.activeExcalidrawView=null,this.lastActiveExcalidrawFilePath=null,this.hover={linkText:null,sourcePath:null},this.opencount=0,this.filesMaster=null,this.equationsMaster=null,this.mathjax=null,this.mathjaxDiv=null,this.mathjaxLoaderFinished=!1,this.fourthFontDef=VIRGIL_FONT,this.packageMap=new WeakMap,this.leafChangeTimeout=null,this.popScope=null,this.filesMaster=new Map,this.equationsMaster=new Map}getPackage(e){if(e===window)return{react:react,reactDOM:reactDOM,excalidrawLib:excalidrawLib};if(this.packageMap.has(e))return this.packageMap.get(e);const{react:t,reactDOM:A,excalidrawLib:i}=e.eval.call(e,`(function() {\n ${lzStringExports.decompressFromBase64(EXCALIDRAW_PACKAGES)};\n return {react:React,reactDOM:ReactDOM,excalidrawLib:ExcalidrawLib};\n })()`);return this.packageMap.set(e,{react:t,reactDOM:A,excalidrawLib:i}),{react:t,reactDOM:A,excalidrawLib:i}}async onload(){if(obsidian_module.addIcon(ICON_NAME,EXCALIDRAW_ICON),obsidian_module.addIcon("ScriptEngine",SCRIPTENGINE_ICON),obsidian_module.addIcon("export-img",EXPORT_IMG_ICON),await this.loadSettings({reEnableAutosave:!0}),imageCache.plugin=this,this.addSettingTab(new ExcalidrawSettingTab(this.app,this)),this.ea=await initExcalidrawAutomate(this),this.registerView("excalidraw",(e=>new ExcalidrawView(e,this))),this.registerExtensions(["excalidraw"],"excalidraw"),this.addMarkdownPostProcessor(),this.registerInstallCodeblockProcessor(),this.addThemeObserver(),this.experimentalFileTypeDisplayToggle(this.settings.experimentalFileType),this.registerCommands(),this.registerEventListeners(),this.initializeFourthFont(),this.registerEditorSuggest(new FieldSuggester(this)),this.registerMonkeyPatches(),this.settings.showReleaseNotes){const e="0.0.0"===this.settings.previousRelease;isVersionNewerThanOther(PLUGIN_VERSION,this.settings.previousRelease)&&new ReleaseNotes(this.app,this,e?null:PLUGIN_VERSION).open()}this.switchToExcalidarwAfterLoad(),this.loadMathJax();const e=this;this.app.workspace.onLayoutReady((()=>{this.scriptEngine=new ScriptEngine(e)})),this.taskbone=new Taskbone(this)}initializeFourthFont(){this.app.workspace.onLayoutReady((async()=>{const e=await getFontDataURL(this.app,this.settings.experimantalFourthFont,"","LocalFont"),t=""===e.dataURL?VIRGIL_DATAURL:e.dataURL;this.fourthFontDef=e.fontDef;const A=new Set;app.workspace.iterateAllLeaves((e=>{const i=app.isMobile?document:e.view.containerEl.ownerDocument;if(!i)return;if(A.has(i))return;A.add(i);const n=i.createElement("style");n.id="local-font-stylesheet",n.textContent=`\n @font-face {\n font-family: 'LocalFont';\n src: url("${t}");\n font-display: swap;\n }\n `;const a=i.getElementById(n.id);i.head.appendChild(n),a&&i.head.removeChild(a),i.fonts.load("20px LocalFont")}))}))}loadMathJax(){const e=this;this.app.workspace.onLayoutReady((async()=>{await obsidian_module.loadMathJax();try{e.mathjaxDiv&&(document.body.removeChild(e.mathjaxDiv),e.mathjax=null,e.mathjaxLoaderFinished=!1),e.mathjaxDiv=document.body.createDiv(),e.mathjaxDiv.title="Excalidraw MathJax Support",e.mathjaxDiv.style.display="none";const t=e.mathjaxDiv.createEl("iframe");t.title="Excalidraw MathJax Support";const A=t.contentWindow.document,i=A.createElement("script");i.type="text/javascript",i.onload=()=>{const A=t.contentWindow;A.MathJax.startup.pagePromise.then((async()=>{const t=app.vault.getAbstractFileByPath("preamble.sty"),i=t&&t instanceof obsidian_module.TFile?await app.vault.read(t):null;try{i&&await A.MathJax.tex2svg(i)}catch(t){errorlog({where:e.loadMathJax,description:"Unexpected error while loading preamble.sty",error:t})}e.mathjax=A.MathJax,e.mathjaxLoaderFinished=!0}))},i.src=e.settings.mathjaxSourceURL,A.head.appendChild(i)}catch(t){new obsidian_module.Notice("Excalidraw: Error initializing LaTeX support"),e.mathjaxLoaderFinished=!0}}))}switchToExcalidarwAfterLoad(){const e=this;this.app.workspace.onLayoutReady((()=>{let t;for(t of app.workspace.getLeavesOfType("markdown"))t.view instanceof obsidian_module.MarkdownView&&e.isExcalidrawFile(t.view.file)&&(e.excalidrawFileModes[t.id||t.view.file.path]="excalidraw",e.setExcalidrawView(t))}))}forceSaveActiveView(e){if(e)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const t=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!t&&(t.forceSave(),!0)}registerInstallCodeblockProcessor(){const e=async(e,t)=>{let A=null;try{const e=t.parentElement.querySelector(`a[href="#${t.previousElementSibling.getAttribute("data-heading")}"]`);e.style.paddingRight="10px",A=e.parentElement.createEl("button",null,(e=>{e.setText(t$d("UPDATE_SCRIPT")),e.addClass("mod-muted"),e.style.backgroundColor="var(--interactive-success)",e.style.display="none"}))}catch(t){errorlog({where:"this.registerInstallCodeblockProcessor",source:e,error:t})}e=e.trim(),t.createEl("button",null,(async t=>{var i;const n=e=>{switch(A&&(A.style.display="none"),e){case"CHECKING":t.setText(t$d("CHECKING_SCRIPT")),t.style.backgroundColor="var(--interactive-normal)";break;case"INSTALL":t.setText(t$d("INSTALL_SCRIPT")),t.style.backgroundColor="var(--interactive-accent)";break;case"UPTODATE":t.setText(t$d("UPTODATE_SCRIPT")),t.style.backgroundColor="var(--interactive-normal)";break;case"UPDATE":t.setText(t$d("UPDATE_SCRIPT")),t.style.backgroundColor="var(--interactive-success)",A&&(A.style.display=null);break;case"ERROR":t.setText(t$d("UNABLETOCHECK_SCRIPT")),t.style.backgroundColor="var(--interactive-normal)"}};t.addClass("mod-muted");let a=e;try{a=decodeURI(e)}catch(t){errorlog({where:"ExcalidrawPlugin.registerInstallCodeblockProcessor.codeblockProcessor.onClick",source:e,error:t})}const r=a.substring(a.lastIndexOf("/")+1),s=`${this.settings.scriptFolderPath}/Downloaded`,o=app.vault.getFiles().filter((e=>e.path.startsWith(s)&&e.name===r)).sort(((e,t)=>e.path>t.path?1:-1));let l=o[0];const c=null!==(i=null==l?void 0:l.path)&&void 0!==i?i:`${s}/${r}`,d=getIMGFilename(c,"svg");let h=this.app.vault.getAbstractFileByPath(d);if(n(l?"CHECKING":"INSTALL"),t.onclick=async()=>{const t=async(e,t,A)=>{const i=await obsidian_module.request({url:e});return!i||i.startsWith("404: Not Found")?null:(t?await this.app.vault.modify(t,i):(await checkAndCreateFolder(s),t=await this.app.vault.create(A,i)),t)};try{if(l=await t(e,l,c),!l)throw n("ERROR"),"File not found";h=await t(getIMGFilename(e,"svg"),h,d),n("UPTODATE"),0===Object.keys(this.scriptEngine.scriptIconMap).length&&this.scriptEngine.loadScripts(),new obsidian_module.Notice(`Installed: ${l.basename}`)}catch(e){new obsidian_module.Notice(`Error installing script: ${r}`),errorlog({where:"ExcalidrawPlugin.registerInstallCodeblockProcessor.codeblockProcessor.onClick",error:e})}},A&&(A.onclick=t.onclick),!(l&&l instanceof obsidian_module.TFile))return;const u=new Map;JSON.parse(await obsidian_module.request({url:"https://raw.githubusercontent.com/zsviczian/obsidian-excalidraw-plugin/master/ea-scripts/directory-info.json"})).forEach((e=>u.set(e.fname,e.mtime)));const g=(e,t)=>{if(0===u.size||!u.has(e))return"ERROR";const A=u.get(e);return!t||A>t.stat.mtime?"UPDATE":"UPTODATE"},p=g(r,l),m=g(getIMGFilename(r,"svg"),h&&h instanceof obsidian_module.TFile?h:null);n("UPTODATE"===p&&"UPTODATE"===m||"UPTODATE"===p&&"ERROR"===m?"UPTODATE":"ERROR"===p?"ERROR":"UPDATE"===p||"UPDATE"===m?"UPDATE":"UPTODATE")}))};this.registerMarkdownCodeBlockProcessor(SCRIPT_INSTALL_CODEBLOCK,(async(t,A)=>{A.addEventListener(RERENDER_EVENT,(async i=>{i.stopPropagation(),A.empty(),e(t,A)})),e(t,A)}))}addMarkdownPostProcessor(){initializeMarkdownPostProcessor(this),this.registerMarkdownPostProcessor(markdownPostProcessor),this.registerEvent(this.app.workspace.on("hover-link",hoverEvent)),this.observer=observer,this.observer.observe(document,{childList:!0,subtree:!0})}addThemeObserver(){this.themeObserver=new MutationObserver((async e=>{var t,A,i,n,a,r,s,o;if(!this.settings.matchThemeTrigger)return;if((null===(t=e[0])||void 0===t?void 0:t.oldValue)===(null===(i=null===(A=e[0])||void 0===A?void 0:A.target)||void 0===i?void 0:i.getAttribute("class")))return;if((null===(a=null===(n=e[0])||void 0===n?void 0:n.oldValue)||void 0===a?void 0:a.includes("theme-dark"))===(null===(o=null===(s=null===(r=e[0])||void 0===r?void 0:r.target)||void 0===s?void 0:s.classList)||void 0===o?void 0:o.contains("theme-dark")))return;const l=isObsidianThemeDark()?"dark":"light";this.app.workspace.getLeavesOfType("excalidraw").forEach((e=>{const t=e.view;t.file&&t.excalidrawRef&&t.setTheme(l)}))})),this.themeObserver.observe(document.body,{attributeOldValue:!0,attributeFilter:["class"]})}experimentalFileTypeDisplayToggle(e){e?this.experimentalFileTypeDisplay():(this.fileExplorerObserver&&this.fileExplorerObserver.disconnect(),this.fileExplorerObserver=null)}experimentalFileTypeDisplay(){const e=e=>{if(1!=e.childElementCount)return;const t=e.getAttribute("data-path");if(!t)return;const A=this.app.vault.getAbstractFileByPath(t);A&&A instanceof obsidian_module.TFile&&this.isExcalidrawFile(A)&&e.insertBefore(createDiv({cls:"nav-file-tag",text:this.settings.experimentalFileTag}),e.firstChild)};this.fileExplorerObserver=new MutationObserver((t=>{const A=t.filter((e=>e.addedNodes.length>0));A.forEach((t=>{t.addedNodes.forEach((t=>{t instanceof Element&&t.querySelectorAll(".nav-file-title").forEach(e)}))}))}));const t=this;this.app.workspace.onLayoutReady((()=>{document.querySelectorAll(".nav-file-title").forEach(e),t.fileExplorerObserver.observe(document.querySelector(".workspace"),{childList:!0,subtree:!0})}))}registerCommands(){this.openDialog=new OpenFileDialog(this.app,this),this.insertLinkDialog=new InsertLinkDialog(this.app),this.insertImageDialog=new InsertImageDialog(this),this.importSVGDialog=new ImportSVGDialog(this),this.insertMDDialog=new InsertMDDialog(this),this.addRibbonIcon(ICON_NAME,t$d("CREATE_NEW"),(async e=>{this.createAndOpenDrawing(getDrawingFilename(this.settings),linkClickModifierType(emulateCTRLClickForLinks(e)))})),this.registerEvent(this.app.workspace.on("file-menu",((e,t)=>{e.addItem((e=>{e.setTitle(t$d("CREATE_NEW")).setIcon(ICON_NAME).onClick((e=>{let A=t.path;t instanceof obsidian_module.TFile&&(A=obsidian_module.normalizePath(t.path.substr(0,t.path.lastIndexOf(t.name)))),this.createAndOpenDrawing(getDrawingFilename(this.settings),linkClickModifierType(emulateCTRLClickForLinks(e)),A)}))}))}))),this.registerEvent(this.app.workspace.on("file-menu",((e,t)=>{t instanceof obsidian_module.TFile&&"excalidraw"==t.extension&&e.addItem((e=>{e.setTitle(t$d("CONVERT_FILE_KEEP_EXT")).onClick((()=>{this.convertSingleExcalidrawToMD(t,!1,!1)}))}))}))),this.registerEvent(this.app.workspace.on("file-menu",((e,t)=>{t instanceof obsidian_module.TFile&&"excalidraw"==t.extension&&e.addItem((e=>{e.setTitle(t$d("CONVERT_FILE_REPLACE_EXT")).onClick((()=>{this.convertSingleExcalidrawToMD(t,!0,!0)}))}))}))),this.addCommand({id:"excalidraw-disable-autosave",name:t$d("TEMPORARY_DISABLE_AUTOSAVE"),checkCallback:e=>!!this.settings.autosave&&(e||(this.settings.autosave=!1),!0)}),this.addCommand({id:"excalidraw-enable-autosave",name:t$d("TEMPORARY_ENABLE_AUTOSAVE"),checkCallback:e=>!this.settings.autosave&&(e||(this.settings.autosave=!0),!0)}),this.addCommand({id:"excalidraw-download-lib",name:t$d("DOWNLOAD_LIBRARY"),callback:this.exportLibrary}),this.addCommand({id:"excalidraw-open",name:t$d("OPEN_EXISTING_NEW_PANE"),callback:()=>{this.openDialog.start(openDialogAction.openFile,!0)}}),this.addCommand({id:"excalidraw-open-on-current",name:t$d("OPEN_EXISTING_ACTIVE_PANE"),callback:()=>{this.openDialog.start(openDialogAction.openFile,!1)}}),this.addCommand({id:"excalidraw-insert-transclusion",name:t$d("TRANSCLUDE"),checkCallback:e=>e?Boolean(this.app.workspace.getActiveViewOfType(obsidian_module.MarkdownView)):(this.openDialog.start(openDialogAction.insertLinkToDrawing,!1),!0)}),this.addCommand({id:"excalidraw-insert-last-active-transclusion",name:t$d("TRANSCLUDE_MOST_RECENT"),checkCallback:e=>{if(e)return Boolean(this.app.workspace.getActiveViewOfType(obsidian_module.MarkdownView))&&null!=this.lastActiveExcalidrawFilePath;const t=this.app.vault.getAbstractFileByPath(this.lastActiveExcalidrawFilePath);return t instanceof obsidian_module.TFile&&(this.embedDrawing(t),!0)}}),this.addCommand({id:"excalidraw-autocreate",name:t$d("NEW_IN_NEW_PANE"),callback:()=>{this.createAndOpenDrawing(getDrawingFilename(this.settings),"new-pane")}}),this.addCommand({id:"excalidraw-autocreate-newtab",name:t$d("NEW_IN_NEW_TAB"),callback:()=>{this.createAndOpenDrawing(getDrawingFilename(this.settings),"new-tab")}}),this.addCommand({id:"excalidraw-autocreate-on-current",name:t$d("NEW_IN_ACTIVE_PANE"),callback:()=>{this.createAndOpenDrawing(getDrawingFilename(this.settings),"active-pane")}}),this.addCommand({id:"excalidraw-autocreate-popout",name:t$d("NEW_IN_POPOUT_WINDOW"),checkCallback:e=>{if(e)return!app.isMobile;this.createAndOpenDrawing(getDrawingFilename(this.settings),"popout-window")}});const e=async e=>{const t=this.app.workspace.getActiveViewOfType(obsidian_module.MarkdownView);if(!t)return;const A=getEmbedFilename(t.file.basename,this.settings),i=this.settings.embedUseExcalidrawFolder?null:(await getAttachmentsFolderAndFilePath(this.app,t.file.path,A)).folder,n=await this.createDrawing(A,i);await this.embedDrawing(n),this.openDrawing(n,e,!0,void 0,!0)};this.addCommand({id:"excalidraw-autocreate-and-embed",name:t$d("NEW_IN_NEW_PANE_EMBED"),checkCallback:t=>t?Boolean(this.app.workspace.getActiveViewOfType(obsidian_module.MarkdownView)):(e("new-pane"),!0)}),this.addCommand({id:"excalidraw-autocreate-and-embed-new-tab",name:t$d("NEW_IN_NEW_TAB_EMBED"),checkCallback:t=>t?Boolean(this.app.workspace.getActiveViewOfType(obsidian_module.MarkdownView)):(e("new-tab"),!0)}),this.addCommand({id:"excalidraw-autocreate-and-embed-on-current",name:t$d("NEW_IN_ACTIVE_PANE_EMBED"),checkCallback:t=>t?Boolean(this.app.workspace.getActiveViewOfType(obsidian_module.MarkdownView)):(e("active-pane"),!0)}),this.addCommand({id:"excalidraw-autocreate-and-embed-popout",name:t$d("NEW_IN_POPOUT_WINDOW_EMBED"),checkCallback:t=>t?!app.isMobile&&Boolean(this.app.workspace.getActiveViewOfType(obsidian_module.MarkdownView)):(e("popout-window"),!0)}),this.addCommand({id:"run-ocr",name:t$d("RUN_OCR"),checkCallback:e=>{const t=this.app.workspace.getActiveViewOfType(ExcalidrawView);return e?Boolean(t):!!t&&(this.settings.taskboneEnabled?(this.taskbone.getTextForView(t,!1),!0):(new obsidian_module.Notice("Taskbone OCR is not enabled. Please go to plugins settings to enable it.",4e3),!0))}}),this.addCommand({id:"search-text",name:t$d("SEARCH"),checkCallback:e=>{if(e)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const t=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!t&&(search(t),!0)}}),this.addCommand({id:"fullscreen",name:t$d("TOGGLE_FULLSCREEN"),checkCallback:e=>{if(e)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const t=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!t&&(t.isFullscreen()?t.exitFullscreen():t.gotoFullscreen(),!0)}}),this.addCommand({id:"disable-binding",name:t$d("TOGGLE_DISABLEBINDING"),checkCallback:e=>{if(e)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const t=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!t&&(t.toggleDisableBinding(),!0)}}),this.addCommand({id:"export-image",name:t$d("EXPORT_IMAGE"),checkCallback:e=>{if(e)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const t=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!t&&(t.exportDialog||(t.exportDialog=new ExportDialog(this,t,t.file),t.exportDialog.createForm()),t.exportDialog.open(),!0)}}),this.forceSaveCommand=this.addCommand({id:"save",hotkeys:[{modifiers:["Ctrl"],key:"s"}],name:t$d("FORCE_SAVE"),checkCallback:e=>this.forceSaveActiveView(e)}),this.addCommand({id:"toggle-lock",hotkeys:[{modifiers:["Ctrl","Shift"],key:"e"}],name:t$d("TOGGLE_LOCK"),checkCallback:e=>{if(e)return!!Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView))&&!this.app.workspace.getActiveViewOfType(ExcalidrawView).compatibilityMode;const t=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!(!t||t.compatibilityMode||(t.changeTextMode(t.textMode===TextMode.parsed?TextMode.raw:TextMode.parsed),0))}}),this.addCommand({id:"scriptengine-store",name:t$d("INSTALL_SCRIPT_BUTTON"),checkCallback:e=>e?Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView)):(new ScriptInstallPrompt(this).open(),!0)}),this.addCommand({id:"delete-file",name:t$d("DELETE_FILE"),checkCallback:e=>{if(e)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const t=this.app.workspace.getActiveViewOfType(ExcalidrawView);if(t){this.ea.reset(),this.ea.setView(t);const e=this.ea.getViewSelectedElement();if("image"!==e.type)return new obsidian_module.Notice("Please select an image or embedded markdown document",4e3),!0;const A=this.ea.getViewFileForImageElement(e);return A?(this.app.vault.delete(A),this.ea.deleteViewElements([e]),!0):(new obsidian_module.Notice("Please select an image or embedded markdown document",4e3),!0)}return!1}}),this.addCommand({id:"insert-link",hotkeys:[{modifiers:["Ctrl","Shift"],key:"k"}],name:t$d("INSERT_LINK"),checkCallback:e=>{if(e)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const t=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!t&&(this.insertLinkDialog.start(t.file.path,t.addText),!0)}}),this.addCommand({id:"insert-link-to-element",hotkeys:[{modifiers:["Ctrl","Shift"],key:"k"}],name:t$d("INSERT_LINK_TO_ELEMENT_NORMAL"),checkCallback:e=>{if(e)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const t=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!t&&(t.copyLinkToSelectedElementToClipboard(""),!0)}}),this.addCommand({id:"insert-link-to-element-group",name:t$d("INSERT_LINK_TO_ELEMENT_GROUP"),checkCallback:e=>{if(e)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const t=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!t&&(t.copyLinkToSelectedElementToClipboard("group="),!0)}}),this.addCommand({id:"insert-link-to-element-frame",name:t$d("INSERT_LINK_TO_ELEMENT_FRAME"),checkCallback:e=>{if(e)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const t=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!t&&(t.copyLinkToSelectedElementToClipboard("frame="),!0)}}),this.addCommand({id:"insert-link-to-element-area",name:t$d("INSERT_LINK_TO_ELEMENT_AREA"),checkCallback:e=>{if(e)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const t=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!t&&(t.copyLinkToSelectedElementToClipboard("area="),!0)}}),this.addCommand({id:"toggle-lefthanded-mode",name:t$d("TOGGLE_LEFTHANDED_MODE"),checkCallback:e=>{if(e){if(this.app.workspace.getActiveViewOfType(ExcalidrawView)){const e=this.app.workspace.getActiveViewOfType(ExcalidrawView),t=null==e?void 0:e.excalidrawAPI;return!!t&&!!t.getAppState().trayModeEnabled}return!1}return this.app.workspace.getActiveViewOfType(ExcalidrawView),(async()=>{const e=this.settings.isLeftHanded;await this.loadSettings({applyLefthandedMode:!1}),this.settings.isLeftHanded=!e,this.saveSettings(),setLeftHandedMode(!e),setTimeout((()=>setLeftHandedMode(!e)))})(),!0}}),this.addCommand({id:"reset-image-to-100",name:t$d("RESET_IMG_TO_100"),checkCallback:e=>{const t=this.app.workspace.getActiveViewOfType(ExcalidrawView);if(!t)return!1;if(!t.excalidrawAPI)return!1;const A=t.getViewSelectedElements().filter((e=>"image"===e.type));if(1!==A.length)return e||new obsidian_module.Notice("Select a single image element and try again"),!1;const i=A[0];return t.excalidrawData.getFile(i.fileId)?!!e||void(async()=>{const e=new ExcalidrawAutomate(this,t),n=await e.getOriginalImageSize(i);if(n){e.copyViewElementsToEAforEditing(A);const t=e.getElement(i.id);t.width=n.width,t.height=n.height,e.addElementsToView(!1,!1,!1)}})():(e||new obsidian_module.Notice("Select a single image element and try again"),!1)}}),this.addCommand({id:"insert-image",name:t$d("INSERT_IMAGE"),checkCallback:e=>{if(e)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const t=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!t&&(this.insertImageDialog.start(t),!0)}}),this.addCommand({id:"import-svg",name:t$d("IMPORT_SVG"),checkCallback:e=>{if(e)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const t=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!t&&(this.importSVGDialog.start(t),!0)}}),this.addCommand({id:"release-notes",name:t$d("READ_RELEASE_NOTES"),checkCallback:e=>e?Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView)):(new ReleaseNotes(this.app,this,PLUGIN_VERSION).open(),!0)}),this.addCommand({id:"tray-mode",name:t$d("TRAY_MODE"),checkCallback:e=>{if(e){const e=this.app.workspace.getActiveViewOfType(ExcalidrawView);if(!e||!e.excalidrawRef)return!1;const t=e.excalidrawAPI.getAppState();return!t.zenModeEnabled&&!t.viewModeEnabled}const t=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!(!t||!t.excalidrawAPI||(t.toggleTrayMode(),0))}}),this.addCommand({id:"insert-md",name:t$d("INSERT_MD"),checkCallback:e=>{if(e)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const t=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!t&&(this.insertMDDialog.start(t),!0)}}),this.addCommand({id:"insert-pdf",name:t$d("INSERT_PDF"),checkCallback:e=>{if(e)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const t=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!t&&(new InsertPDFModal(this,t).open(),!0)}}),this.addCommand({id:"universal-add-file",name:t$d("UNIVERSAL_ADD_FILE"),checkCallback:e=>{if(e)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const t=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!t&&(new UniversalInsertFileModal(this,t).open(),!0)}}),this.addCommand({id:"insert-LaTeX-symbol",name:t$d("INSERT_LATEX"),checkCallback:e=>{if(e)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const t=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!t&&(insertLaTeXToView(t),!0)}}),this.addCommand({id:"toggle-excalidraw-view",name:t$d("TOGGLE_MODE"),checkCallback:e=>{const t=this.app.workspace.getActiveFile();if(!t)return!1;const A=this.isExcalidrawFile(t);if(e)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView))?!this.app.workspace.getActiveViewOfType(ExcalidrawView).compatibilityMode:A;const i=this.app.workspace.getActiveViewOfType(ExcalidrawView);if(i){const e=i.leaf;return this.excalidrawFileModes[e.id||t.path]="markdown",void this.setMarkdownView(e)}const n=this.app.workspace.getActiveViewOfType(obsidian_module.MarkdownView);if(n&&A){const e=n.leaf;return this.excalidrawFileModes[e.id||t.path]="excalidraw",void this.setExcalidrawView(e)}}}),this.addCommand({id:"convert-to-excalidraw",name:t$d("CONVERT_NOTE_TO_EXCALIDRAW"),checkCallback:e=>{const t=this.app.workspace.getActiveFile(),A=this.app.workspace.getActiveViewOfType(obsidian_module.MarkdownView);if(!t||!A)return!1;const i=0===t.stat.size;if(e)return i;i&&(async()=>{await this.app.vault.modify(t,await this.getBlankDrawing()),this.setExcalidrawView(A.leaf)})()}}),this.addCommand({id:"convert-excalidraw",name:t$d("CONVERT_EXCALIDRAW"),checkCallback:e=>{if(e){const e=this.app.vault.getFiles().filter((e=>"excalidraw"==e.extension));return e.length>0}return this.convertExcalidrawToMD(),!0}})}async convertSingleExcalidrawToMD(e,t=!1,A=!1){const i=await this.app.vault.read(e),n=e.name.substring(0,e.name.lastIndexOf(".excalidraw"))+(t?".md":".excalidraw.md"),a=getNewUniqueFilepath(this.app.vault,n,obsidian_module.normalizePath(e.path.substring(0,e.path.lastIndexOf(e.name))));log(a);const r=await this.app.vault.create(a,FRONTMATTER+await this.exportSceneToMD(i));return this.settings.keepInSync&&EXPORT_TYPES.forEach((t=>{const A=e.path.substring(0,e.path.lastIndexOf(".excalidraw"))+t,i=this.app.vault.getAbstractFileByPath(obsidian_module.normalizePath(A));if(i&&i instanceof obsidian_module.TFile){const e=a.substring(0,a.lastIndexOf(".md"))+t;this.app.fileManager.renameFile(i,e)}})),A||this.app.vault.delete(e),r}async convertExcalidrawToMD(e=!1,t=!1){const A=this.app.vault.getFiles().filter((e=>"excalidraw"==e.extension));for(const i of A)this.convertSingleExcalidrawToMD(i,e,t);new obsidian_module.Notice(`Converted ${A.length} files.`)}registerMonkeyPatches(){var e,t;(null===(t=null===(e=app.plugins)||void 0===e?void 0:e.plugins)||void 0===t?void 0:t["obsidian-hover-editor"])||this.register(around(obsidian_module.WorkspaceLeaf.prototype,{getRoot:e=>function(){const t=e.call(this);return t.getRoot===this.getRoot?t:t.getRoot()}})),this.registerEvent(app.workspace.on("editor-menu",((e,t,A)=>{if(!(A&&A instanceof obsidian_module.MarkdownView))return;const i=A.file,n=A.leaf;if(!A.file)return;const a=this.app.metadataCache.getFileCache(i);(null==a?void 0:a.frontmatter)&&a.frontmatter[FRONTMATTER_KEY]&&e.addItem((e=>e.setTitle(t$d("OPEN_AS_EXCALIDRAW")).setIcon(ICON_NAME).setSection("excalidraw").onClick((()=>{this.excalidrawFileModes[n.id||i.path]="excalidraw",this.setExcalidrawView(n)}))))}))),this.registerEvent(app.workspace.on("file-menu",((e,t,A,i)=>{if(!(i&&i.view instanceof obsidian_module.MarkdownView))return;if(!(t instanceof obsidian_module.TFile))return;const n=this.app.metadataCache.getFileCache(t);(null==n?void 0:n.frontmatter)&&n.frontmatter[FRONTMATTER_KEY]&&(e.addItem((e=>{e.setTitle(t$d("OPEN_AS_EXCALIDRAW")).setIcon(ICON_NAME).setSection("pane").onClick((()=>{this.excalidrawFileModes[i.id||t.path]="excalidraw",this.setExcalidrawView(i)}))})),e.items.unshift(e.items.pop()))})));const A=this;this.register(around(obsidian_module.WorkspaceLeaf.prototype,{detach:e=>function(){var t;const i=null===(t=this.view)||void 0===t?void 0:t.getState();return(null==i?void 0:i.file)&&A.excalidrawFileModes[this.id||i.file]&&delete A.excalidrawFileModes[this.id||i.file],e.apply(this)},setViewState:e=>function(t,...i){var n;if(A._loaded&&"markdown"===t.type&&(null===(n=t.state)||void 0===n?void 0:n.file)&&"markdown"!==A.excalidrawFileModes[this.id||t.state.file]){const n=app.metadataCache.getCache(t.state.file);if((null==n?void 0:n.frontmatter)&&n.frontmatter[FRONTMATTER_KEY]){const n=Object.assign(Object.assign({},t),{type:"excalidraw"});return A.excalidrawFileModes[t.state.file]="excalidraw",e.apply(this,[n,...i])}}return e.apply(this,[t,...i])}}))}registerEventListeners(){const e=this;this.app.workspace.onLayoutReady((async()=>{e.registerEvent(app.vault.on("rename",(async(t,A)=>{t instanceof obsidian_module.TFile&&e.isExcalidrawFile(t)&&e.settings.keepInSync&&[EXPORT_TYPES,"excalidraw"].flat().forEach((async e=>{const i=getIMGFilename(A,e),n=app.vault.getAbstractFileByPath(obsidian_module.normalizePath(i));if(n&&n instanceof obsidian_module.TFile){const A=getIMGFilename(t.path,e);await app.fileManager.renameFile(n,A)}}))}))),e.registerEvent(app.vault.on("modify",(async t=>{app.workspace.getLeavesOfType("excalidraw").forEach((async A=>{const i=A.view;if(i.file&&(i.file.path===t.path||"excalidraw"===t.extension&&`${t.path.substring(0,t.path.lastIndexOf(".excalidraw"))}.md`===i.file.path)){if(i.semaphores.preventReload)return void(i.semaphores.preventReload=!1);if(i.lastSaveTimestamp+3e5{if(!(t instanceof obsidian_module.TFile))return;const A=this.excalidrawFiles.has(t);if(this.updateFileCache(t,void 0,!0),!A)return;const i=app.workspace.getLeavesOfType("excalidraw");for(let e=0;e{[EXPORT_TYPES,"excalidraw"].flat().forEach((async e=>{const A=getIMGFilename(t.path,e),i=app.vault.getAbstractFileByPath(obsidian_module.normalizePath(A));i&&i instanceof obsidian_module.TFile&&await app.vault.delete(i)}))}),500)}))),e.registerEvent(app.workspace.on("active-leaf-change",(async t=>{var A;e.leafChangeTimeout&&clearTimeout(e.leafChangeTimeout),e.leafChangeTimeout=setTimeout((()=>{e.leafChangeTimeout=null}),1e3);const i=e.activeExcalidrawView,n=t.view instanceof ExcalidrawView?t.view:null; +//!Temporary hack +if(e.activeExcalidrawView=n,n&&(e.lastActiveExcalidrawFilePath=null===(A=n.file)||void 0===A?void 0:A.path),app.isMobile&&n&&!i){const e=document.querySelector("body>.app-container>.mobile-navbar");e&&e instanceof HTMLDivElement&&(e.style.position="relative")}if(app.isMobile&&!n&&i){const e=document.querySelector("body>.app-container>.mobile-navbar");e&&e instanceof HTMLDivElement&&(e.style.position="")}if(i&&i!==n&&(i.leaf!==t&&i.semaphores.dirty&&!i.semaphores.viewunload&&await i.save(!0),i.file&&e.triggerEmbedUpdates(i.file.path)),n&&(!i||i.leaf!==t)){const e=n.file;n.file&&setTimeout((()=>{var t;n&&n._loaded&&(null===(t=n.file)||void 0===t?void 0:t.path)===(null==e?void 0:e.path)&&(n.activeLoader||n.loadSceneFiles())}),2e3)}if(n&&n._loaded&&n.isLoaded&&n.excalidrawAPI&&e.ea.onCanvasColorChangeHook&&e.ea.onCanvasColorChangeHook(e.ea,n,n.excalidrawAPI.getAppState().viewBackgroundColor),e.popScope&&(e.popScope(),e.popScope=null),n){const t=e.app.keymap.getRootScope(),A=t.register(["Mod"],"Enter",(()=>!0));t.keys.unshift(t.keys.pop());const i=t.register(["Mod"],"k",(()=>!0));t.keys.unshift(t.keys.pop());const n=t.register(["Mod"],"f",(()=>{const e=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!e&&(search(e),!0)}));t.keys.unshift(t.keys.pop());const a=e.forceSaveCommand&&"s"===e.forceSaveCommand.hotkeys[0].key&&e.forceSaveCommand.hotkeys[0].modifiers.includes("Ctrl")?t.register(["Ctrl"],"s",(()=>e.forceSaveActiveView(!1))):void 0;a&&t.keys.unshift(t.keys.pop()),e.popScope=()=>{t.unregister(A),t.unregister(i),t.unregister(n),Boolean(a)&&t.unregister(a)}}}))),e.addFileSaveTriggerEventHandlers();const t=app.metadataCache;t.getCachedFiles().forEach((A=>{var i;const n=null===(i=t.getCache(A))||void 0===i?void 0:i.frontmatter;(n&&void 0!==n[FRONTMATTER_KEY]||A.match(/\.excalidraw$/))&&e.updateFileCache(app.vault.getAbstractFileByPath(A),n)})),this.registerEvent(t.on("changed",((e,t,A)=>this.updateFileCache(e,null==A?void 0:A.frontmatter))))}))}addFileSaveTriggerEventHandlers(){this.registerEvent(this.app.workspace.on("click",(e=>{this.activeExcalidrawView&&this.activeExcalidrawView.semaphores.dirty&&(!e.target||"excalidraw__canvas"!==e.target.className&&!getParentOfClass(e.target,"excalidraw-wrapper"))&&this.activeExcalidrawView.save()}))),this.registerEvent(this.app.workspace.on("file-menu",(()=>{this.activeExcalidrawView&&this.activeExcalidrawView.semaphores.dirty&&this.activeExcalidrawView.save()}))),this.modalContainerObserver=new MutationObserver((async e=>{1===e.length&&"childList"===e[0].type&&1===e[0].addedNodes.length&&this.activeExcalidrawView&&this.activeExcalidrawView.semaphores.dirty&&this.activeExcalidrawView.save()})),this.modalContainerObserver.observe(document.body,{childList:!0});const e=document.querySelector(".workspace-drawer.mod-left"),t=document.querySelector(".workspace-drawer.mod-right");if(e||t){const A=async e=>{"display: none;"===e[0].oldValue&&this.activeExcalidrawView&&this.activeExcalidrawView.semaphores.dirty&&this.activeExcalidrawView.save()},i={attributeOldValue:!0,attributeFilter:["style"]};e&&(this.workspaceDrawerLeftObserver=new MutationObserver(A),this.workspaceDrawerLeftObserver.observe(e,i)),t&&(this.workspaceDrawerRightObserver=new MutationObserver(A),this.workspaceDrawerRightObserver.observe(t,i))}}updateFileCache(e,t,A=!1){t&&void 0!==t[FRONTMATTER_KEY]?this.excalidrawFiles.add(e):A||"excalidraw"!==e.extension?this.excalidrawFiles.delete(e):this.excalidrawFiles.add(e)}onunload(){destroyExcalidrawAutomate(),this.popScope&&(this.popScope(),this.popScope=null),this.observer.disconnect(),this.themeObserver.disconnect(),this.modalContainerObserver.disconnect(),this.workspaceDrawerLeftObserver&&this.workspaceDrawerLeftObserver.disconnect(),this.workspaceDrawerRightObserver&&this.workspaceDrawerRightObserver.disconnect(),this.fileExplorerObserver&&this.fileExplorerObserver.disconnect(),this.app.workspace.getLeavesOfType("excalidraw").forEach((e=>{this.setMarkdownView(e)})),this.mathjaxDiv&&document.body.removeChild(this.mathjaxDiv),Object.values(this.packageMap).forEach((e=>{delete e.excalidrawLib,delete e.reactDOM,delete e.react}))}async embedDrawing(e){const t=this.app.workspace.getActiveViewOfType(obsidian_module.MarkdownView);if(t&&t.file){const A=this.app.metadataCache.fileToLinktext(e,t.file.path,"excalidraw"===this.settings.embedType),i=t.editor;if("excalidraw"===this.settings.embedType)return i.replaceSelection(this.settings.embedWikiLink?`![[${A}]]`:`![](${encodeURI(A)})`),void i.focus();let n=this.settings.autoExportLightAndDark?getExportTheme(this,e,this.settings.exportWithTheme&&isObsidianThemeDark()?"dark":"light"):"";n=""===n?"":n+".";const a=getIMGFilename(A,n+this.settings.embedType.toLowerCase()),r=getIMGFilename(e.path,n+this.settings.embedType.toLowerCase()),s="dark."===n?"light.":"dark.",o=getIMGFilename(A,s+this.settings.embedType.toLowerCase());this.app.vault.getAbstractFileByPath(r)||(await this.app.vault.create(r,""),await sleep$1(200)),i.replaceSelection(this.settings.embedWikiLink?`![[${a}]]\n%%[[${A}|🖋 Edit in Excalidraw]]${o?", and the [["+o+"|"+s.split(".")[0]+" exported image]]":""}%%`:`![](${encodeURI(a)})\n%%[🖋 Edit in Excalidraw](${encodeURI(A)})${o?", and the ["+s.split(".")[0]+" exported image]("+encodeURI(o)+")":""}%%`),i.focus()}}async loadSettings(e={applyLefthandedMode:!0,reEnableAutosave:!1}){void 0===e.applyLefthandedMode&&(e.applyLefthandedMode=!0),void 0===e.reEnableAutosave&&(e.reEnableAutosave=!1),this.settings=Object.assign({},DEFAULT_SETTINGS,await this.loadData()),e.applyLefthandedMode&&setLeftHandedMode(this.settings.isLeftHanded),e.reEnableAutosave&&(this.settings.autosave=!0),this.settings.autosaveInterval=app.isMobile?this.settings.autosaveIntervalMobile:this.settings.autosaveIntervalDesktop}async saveSettings(){await this.saveData(this.settings)}getStencilLibrary(){return""===this.settings.library||"deprecated"===this.settings.library?this.settings.library2:JSON_parse(this.settings.library)}setStencilLibrary(e){this.settings.library="deprecated",this.settings.library2=e}triggerEmbedUpdates(e){const t=new Set;app.workspace.iterateAllLeaves((A=>{const i=app.isMobile?document:A.view.containerEl.ownerDocument;if(!i)return;if(t.has(i))return;t.add(i);const n=i.createEvent("Event");n.initEvent(RERENDER_EVENT,!0,!1),i.querySelectorAll("img[class^='excalidraw-svg']"+(e?`[fileSource='${e.replaceAll("'","\\'")}']`:"")).forEach((e=>e.dispatchEvent(n)))}))}openDrawing(e,t,A=!1,i,n=!1){let a;"md-properties"===t&&(t="new-tab"),"popout-window"===t&&(a=app.workspace.openPopoutLeaf()),"new-tab"===t&&(a=app.workspace.getLeaf("tab")),a||(a=this.app.workspace.getLeaf(!1),"empty"!==a.view.getViewType()&&"new-pane"===t&&(a=getNewOrAdjacentLeaf(this,a))),a.openFile(e,i&&""!==i?{active:A,eState:{subpath:i}}:{active:A}).then((()=>{if(n&&this.ea.onFileCreateHook)try{this.ea.onFileCreateHook({ea:this.ea,excalidrawFile:e,view:a.view})}catch(e){console.error(e)}}))}async getBlankDrawing(){const e=this.app.metadataCache.getFirstLinkpathDest(obsidian_module.normalizePath(this.settings.templateFilePath),"");if(e&&e instanceof obsidian_module.TFile&&("md"==e.extension&&!this.settings.compatibilityMode||"excalidraw"==e.extension&&this.settings.compatibilityMode)){const t=await this.app.vault.read(e);if(t)return this.settings.matchTheme?changeThemeOfExcalidrawMD(t):t}if(this.settings.compatibilityMode)return this.settings.matchTheme&&isObsidianThemeDark()?DARK_BLANK_DRAWING:BLANK_DRAWING;const t=this.settings.matchTheme&&isObsidianThemeDark()?DARK_BLANK_DRAWING:BLANK_DRAWING;return`${FRONTMATTER}\n${getMarkdownDrawingSection(t,this.settings.compress)}`}async exportSceneToMD(e){var t,A;if(!e)return"";const i=null===(t=JSON_parse(e).elements)||void 0===t?void 0:t.filter((e=>"text"==e.type));let n,a="# Text Elements\n";for(const t of i)n=t.id,t.id.length>8&&(n=nanoid(),e=e.replaceAll(t.id,n)),a+=`${null!==(A=t.originalText)&&void 0!==A?A:t.text} ^${n}\n\n`;return a+getMarkdownDrawingSection(JSON.stringify(JSON_parse(e),null,"\t"),this.settings.compress)}async createDrawing(e,t,A){const i=obsidian_module.normalizePath(t||this.settings.folder);await checkAndCreateFolder(i);const n=getNewUniqueFilepath(this.app.vault,e,i),a=await this.app.vault.create(n,null!=A?A:await this.getBlankDrawing());let r=0;for(;a instanceof obsidian_module.TFile&&!this.isExcalidrawFile(a)&&r++<10;)await sleep$1(50);return r>10&&errorlog({file:a,error:"new drawing not recognized as an excalidraw file",fn:this.createDrawing}),a}async createAndOpenDrawing(e,t,A,i){const n=await this.createDrawing(e,A,i);return this.openDrawing(n,t,!0,void 0,!0),n.path}async setMarkdownView(e){const t=e.view.getState();await e.setViewState({type:"excalidraw",state:{file:null}}),await e.setViewState({type:"markdown",state:t,popstate:!0},{focus:!0})}async setExcalidrawView(e){await e.setViewState({type:"excalidraw",state:e.view.getState(),popstate:!0})}isExcalidrawFile(e){if(!e)return!1;if("excalidraw"===e.extension)return!0;const t=e?this.app.metadataCache.getFileCache(e):null;return!!(null==t?void 0:t.frontmatter)&&!!t.frontmatter[FRONTMATTER_KEY]}async exportLibrary(){this.app.isMobile?new Prompt(this.app,"Please provide a filename","my-library","filename, leave blank to cancel action").openAndGetValue((async e=>{if(!e)return;e=`${e}.excalidrawlib`;const t=obsidian_module.normalizePath(this.settings.folder);await checkAndCreateFolder(t);const A=getNewUniqueFilepath(this.app.vault,e,t);this.app.vault.create(A,this.settings.library),new obsidian_module.Notice(`Exported library to ${A}`,6e3)})):download("data:text/plain;charset=utf-8",encodeURIComponent(JSON.stringify(this.settings.library2,null,"\t")),"my-obsidian-library.excalidrawlib")}}module.exports=ExcalidrawPlugin; diff --git a/.obsidian/plugins/obsidian-excalidraw-plugin/manifest.json b/.obsidian/plugins/obsidian-excalidraw-plugin/manifest.json new file mode 100644 index 0000000..89b6143 --- /dev/null +++ b/.obsidian/plugins/obsidian-excalidraw-plugin/manifest.json @@ -0,0 +1,11 @@ +{ + "id": "obsidian-excalidraw-plugin", + "name": "Excalidraw", + "version": "1.9.10", + "minAppVersion": "1.1.6", + "description": "An Obsidian plugin to edit and view Excalidraw drawings", + "author": "Zsolt Viczian", + "authorUrl": "https://zsolt.blog", + "fundingUrl": "https://ko-fi.com/zsolt", + "isDesktopOnly": false +} diff --git a/.obsidian/plugins/obsidian-excalidraw-plugin/styles.css b/.obsidian/plugins/obsidian-excalidraw-plugin/styles.css new file mode 100644 index 0000000..ef8f9b5 --- /dev/null +++ b/.obsidian/plugins/obsidian-excalidraw-plugin/styles.css @@ -0,0 +1,367 @@ +.App { + font-family: sans-serif; + text-align: center; + } + + .excalidraw-wrapper { + height: 100%; + margin: 0px; + background-color: white; + } + + .context-menu-option__shortcut { + background-color: transparent !important; + } + +.block-language-excalidraw { + text-align:center; +} + +.excalidraw .github-corner { + display: none; +} + +img.excalidraw-embedded-img { + width: 100%; +} + +img.excalidraw-svg-right-wrap { + float: right; + margin: 0px 0px 20px 20px; +} + +img.excalidraw-svg-left-wrap { + float: left; + margin: 0px 35px 20px 0px; +} + +img.excalidraw-svg-right { + float: right; +} + +.excalidraw-svg-center { + text-align: center; +} + +img.excalidraw-svg-left { + float: left; +} + +div.excalidraw-svg-right, +div.excalidraw-svg-left { + display: table; + width: 100%; +} + +button.ToolIcon_type_button[title="Export"] { + display:none; +} + +.excalidraw-prompt-div { + display: flex; + max-width: 800px; +} + +.excalidraw-prompt-form { + display: flex; + flex-grow: 1; +} + +.excalidraw-prompt-input { + flex-grow: 1; +} + +.excalidraw-prompt-button { + width: 9em; +} + +.excalidraw-prompt-buttons-div { + display: flex; + flex-direction: row; + flex-wrap: nowrap; + justify-content: space-evenly; +} + +li[data-testid] { + border: 0 !important; + margin: 0 !important; + padding: 0 !important; + width: 100% !important; +} + +.excalidraw .context-menu-option-separator { + margin: 4px !important; +} + +.excalidraw .popover { + padding: 0 !important; + border-color: transparent !important; + border: 0 !important; + box-shadow: 0 !important; + background-color: transparent !important; +} + +.disable-zen-mode--visible { + color: var(--text-primary-color); +} + +.disable-zen-mode { + width: 9em !important; +} + +.ex-coffee-div { + text-align: center; + margin-bottom: 10px; +} + +.excalidraw-scriptengine-install td>img { + width: 100%; + max-width:800px; +} + +.excalidraw-scriptengine-install img.coffee { + width: 130px; +} + +.excalidraw-scriptengine-install tr { + vertical-align: top; +} + +.excalidraw-scriptengine-install table { + max-width: 130ch; +} + +.excalidraw-scriptengine-install td.label { + min-width: 11ch; + font-weight: bold; + padding-right: 5px; +} + +.excalidraw-scriptengine-install td.data { + width: 100%; +} + +.excalidraw-scriptengine-install .modal-content { + max-width: 130ch; + user-select: text; +} + +.excalidraw-scriptengine-install .modal { + max-height:90%; + width: auto; +} + +.excalidraw-prompt-center { + text-align: center !important; +} + +.excalidraw-prompt-center button { + margin: 0 10px; +} + +.excalidraw-prompt-center.filepath { + text-align: center; + font-weight: bold; + margin-bottom: 2em; +} + +.excalidraw-dirty { + color: red; +} + +.workspace-leaf-content .excalidraw-view { + padding: 0px 1px; /*1px so on ipad swipe in from left and right still works*/ + overflow: hidden; +} + +.excalidraw-videoWrapper { + max-width:600px +} +.excalidraw-videoWrapper div { + position: relative; + padding-bottom: 56.25%; + height: 0; + margin: 0 auto; +} + +.excalidraw-videoWrapper iframe { + position: absolute; + top: 0; + left: 0; + width: 100%; + height: 100%; +} + +.excalidraw-release .modal-content{ + padding-right: 5px; + margin-right: -5px; + user-select: text; +} + +.excalidraw-release .modal { + max-height: 80%; + max-width: 42em; +} + +.excalidraw .Island .scrollbar { + --scrollbar-thumb-bg: silver; +} + +.excalidraw .ToolIcon__icon img{ + height: 1em; +} + +.excalidraw-scriptengine-install tbody>tr>td>div>img { + height:20px; + background-color: silver; + padding: 2px; +} + +.excalidraw-scriptengine-install tbody>tr>td>div { + width: 50px; + display: inline-block; +} + +.excalidraw-release p>a>img { + width: 100% +} + +.excalidraw .context-menu-option { + box-shadow: none; +} + +textarea.excalidraw-wysiwyg { + border: none; + outline: none; + -webkit-box-shadow: none; + -moz-box-shadow: none; + box-shadow: none; + border-radius: 0; +} + +.is-tablet .excalidraw button, +.is-mobile .excalidraw button { + padding: initial; + height: 1.8rem; +} + +.excalidraw button, +.ToolIcon button { + box-shadow: none; + justify-content: initial; +} + +.excalidraw { + --default-button-size: 2rem !important; + --default-icon-size: 1rem !important; + --lg-button-size: 1.8rem !important; + --lg-icon-size: 1rem !important; +} + +.excalidraw .tray-zoom { + pointer-events: initial; + padding-bottom: 0.05rem; + padding-top: 0.05rem; +} + +.excalidraw-container.theme--dark { + background-color: #121212; + color: #fff; +} + +/* https://discordapp.com/channels/686053708261228577/989603365606531104/1041266507256184863 */ +/*.workspace-leaf { + contain: none !important; +}*/ + +.color-picker-content { + overflow-y: auto; + max-height: 10rem; +} + +.excalidraw .FixedSideContainer_side_top { + top: 0.3rem; +} + +.excalidraw .ToolIcon__keybinding { + font-size: 0.45rem !important; +} + +.Island > .Stack > .Stack { + padding:0.2rem; +} + +label.color-input-container > input { + max-width: 5rem; +} + +.excalidraw .FixedSideContainer_side_top { + left: 10px !important; + top: 10px !important; + right: 10px !important; + bottom: 10px !important; +} + +.excalidraw-hidden { + display: none !important; +} + +.excalidraw .panelColumn .buttonList { + max-width: 13rem; +} + +.excalidraw button { + width: initial; +} + +.excalidraw input[type="color"] { + width: 1.65rem; + height: 1.65rem; +} + +.excalidraw input[type="color"]::-webkit-color-swatch { + height: 1.65rem; +} + + +.excalidraw input[type="color"]::-webkit-color-swatch-wrapper { + padding: 0; +} + +.excalidraw-settings input { + min-width: 10em; +} + +div.excalidraw-draginfo { + position: absolute; + z-index: 1000; + color: var(--text-normal); + padding: 3px; + background: var(--color-base-40); + display: block; + border-radius: 5px; +} + +.excalidraw [data-radix-popper-content-wrapper] { + position: absolute !important; +} + +.excalidraw__embeddable-container .view-header { + display: none !important; +} + +.excalidraw__embeddable-container input { + background: initial; +} + +.excalidraw .HelpDialog__key { + background-color: var(--color-gray-80) !important; +} + +.excalidraw .embeddable-menu { + width: fit-content; + height: fit-content; + position: absolute; + display: block; + z-index: var(--zIndex-layerUI); +} \ No newline at end of file diff --git a/.obsidian/plugins/obsidian-excalidraw/data.json b/.obsidian/plugins/obsidian-excalidraw/data.json new file mode 100644 index 0000000..e3e2596 --- /dev/null +++ b/.obsidian/plugins/obsidian-excalidraw/data.json @@ -0,0 +1,76 @@ +{ + "folder": "Excalidraw", + "embedUseExcalidrawFolder": false, + "templateFilePath": "Excalidraw/Template.excalidraw", + "scriptFolderPath": "Excalidraw/Scripts", + "compress": true, + "autosave": true, + "autosaveInterval": 10000, + "drawingFilenamePrefix": "Drawing ", + "drawingEmbedPrefixWithFilename": true, + "drawingFilnameEmbedPostfix": " ", + "drawingFilenameDateTime": "YYYY-MM-DD HH.mm.ss", + "useExcalidrawExtension": true, + "displaySVGInPreview": true, + "displayExportedImageIfAvailable": false, + "previewMatchObsidianTheme": false, + "width": "400", + "isLeftHanded": false, + "matchTheme": false, + "matchThemeAlways": false, + "matchThemeTrigger": false, + "defaultMode": "normal", + "defaultPenMode": "mobile", + "zoomToFitOnResize": true, + "zoomToFitMaxLevel": 2, + "linkPrefix": "📍", + "urlPrefix": "🌐", + "hoverPreviewWithoutCTRL": false, + "linkOpacity": 1, + "openInAdjacentPane": false, + "openInMainWorkspace": true, + "showLinkBrackets": true, + "allowCtrlClick": true, + "forceWrap": false, + "pageTransclusionCharLimit": 200, + "wordWrappingDefault": 0, + "iframelyAllowed": true, + "pngExportScale": 1, + "exportWithTheme": true, + "exportWithBackground": true, + "exportPaddingSVG": 10, + "keepInSync": true, + "autoexportSVG": true, + "autoexportPNG": false, + "autoexportExcalidraw": false, + "embedType": "excalidraw", + "embedWikiLink": true, + "syncExcalidraw": false, + "experimentalFileType": false, + "experimentalFileTag": "✏️", + "experimentalLivePreview": true, + "experimentalEnableFourthFont": false, + "experimantalFourthFont": "Virgil", + "fieldSuggester": true, + "compatibilityMode": false, + "drawingOpenCount": 0, + "library": "deprecated", + "library2": { + "type": "excalidrawlib", + "version": 2, + "source": "https://excalidraw.com", + "libraryItems": [] + }, + "imageElementNotice": true, + "mdSVGwidth": 500, + "mdSVGmaxHeight": 800, + "mdFont": "Virgil", + "mdFontColor": "Black", + "mdBorderColor": "Black", + "mdCSS": "", + "scriptEngineSettings": {}, + "defaultTrayMode": false, + "previousRelease": "1.7.7", + "showReleaseNotes": true, + "mathjaxSourceURL": "https://cdn.jsdelivr.net/npm/mathjax@3.2.1/es5/tex-svg.js" +} \ No newline at end of file diff --git a/.obsidian/plugins/obsidian-excalidraw/main.js b/.obsidian/plugins/obsidian-excalidraw/main.js new file mode 100644 index 0000000..0b7f60d --- /dev/null +++ b/.obsidian/plugins/obsidian-excalidraw/main.js @@ -0,0 +1,24 @@ +"use strict";var obsidian=require("obsidian");var LZString=function(){function o(o,r){if(!t[o]){t[o]={};for(var n=0;ne;e++){var s=r.charCodeAt(e);n[2*e]=s>>>8,n[2*e+1]=s%256}return n},decompressFromUint8Array:function(o){if(null===o||void 0===o)return i.decompress(o);for(var n=new Array(o.length/2),e=0,t=n.length;t>e;e++)n[e]=256*o[2*e]+o[2*e+1];var s=[];return n.forEach(function(o){s.push(r(o))}),i.decompress(s.join(""))},compressToEncodedURIComponent:function(o){return null==o?"":i._compress(o,6,function(o){return e.charAt(o)})},decompressFromEncodedURIComponent:function(r){return null==r?"":""==r?null:(r=r.replace(/ /g,"+"),i._decompress(r.length,32,function(n){return o(e,r.charAt(n))}))},compress:function(o){return i._compress(o,16,function(o){return r(o)})},_compress:function(o,r,n){if(null==o)return"";var e,t,i,s={},p={},u="",c="",a="",l=2,f=3,h=2,d=[],m=0,v=0;for(i=0;ie;e++)m<<=1,v==r-1?(v=0,d.push(n(m)),m=0):v++;for(t=a.charCodeAt(0),e=0;8>e;e++)m=m<<1|1&t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t>>=1}else{for(t=1,e=0;h>e;e++)m=m<<1|t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t=0;for(t=a.charCodeAt(0),e=0;16>e;e++)m=m<<1|1&t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t>>=1}l--,0==l&&(l=Math.pow(2,h),h++),delete p[a]}else for(t=s[a],e=0;h>e;e++)m=m<<1|1&t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t>>=1;l--,0==l&&(l=Math.pow(2,h),h++),s[c]=f++,a=String(u)}if(""!==a){if(Object.prototype.hasOwnProperty.call(p,a)){if(a.charCodeAt(0)<256){for(e=0;h>e;e++)m<<=1,v==r-1?(v=0,d.push(n(m)),m=0):v++;for(t=a.charCodeAt(0),e=0;8>e;e++)m=m<<1|1&t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t>>=1}else{for(t=1,e=0;h>e;e++)m=m<<1|t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t=0;for(t=a.charCodeAt(0),e=0;16>e;e++)m=m<<1|1&t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t>>=1}l--,0==l&&(l=Math.pow(2,h),h++),delete p[a]}else for(t=s[a],e=0;h>e;e++)m=m<<1|1&t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t>>=1;l--,0==l&&(l=Math.pow(2,h),h++)}for(t=2,e=0;h>e;e++)m=m<<1|1&t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t>>=1;for(;;){if(m<<=1,v==r-1){d.push(n(m));break}v++}return d.join("")},decompress:function(o){return null==o?"":""==o?null:i._decompress(o.length,32768,function(r){return o.charCodeAt(r)})},_decompress:function(o,n,e){var t,i,s,p,u,c,a,l,f=[],h=4,d=4,m=3,v="",w=[],A={val:e(0),position:n,index:1};for(i=0;3>i;i+=1)f[i]=i;for(p=0,c=Math.pow(2,2),a=1;a!=c;)u=A.val&A.position,A.position>>=1,0==A.position&&(A.position=n,A.val=e(A.index++)),p|=(u>0?1:0)*a,a<<=1;switch(t=p){case 0:for(p=0,c=Math.pow(2,8),a=1;a!=c;)u=A.val&A.position,A.position>>=1,0==A.position&&(A.position=n,A.val=e(A.index++)),p|=(u>0?1:0)*a,a<<=1;l=r(p);break;case 1:for(p=0,c=Math.pow(2,16),a=1;a!=c;)u=A.val&A.position,A.position>>=1,0==A.position&&(A.position=n,A.val=e(A.index++)),p|=(u>0?1:0)*a,a<<=1;l=r(p);break;case 2:return""}for(f[3]=l,s=l,w.push(l);;){if(A.index>o)return"";for(p=0,c=Math.pow(2,m),a=1;a!=c;)u=A.val&A.position,A.position>>=1,0==A.position&&(A.position=n,A.val=e(A.index++)),p|=(u>0?1:0)*a,a<<=1;switch(l=p){case 0:for(p=0,c=Math.pow(2,8),a=1;a!=c;)u=A.val&A.position,A.position>>=1,0==A.position&&(A.position=n,A.val=e(A.index++)),p|=(u>0?1:0)*a,a<<=1;f[d++]=r(p),l=d-1,h--;break;case 1:for(p=0,c=Math.pow(2,16),a=1;a!=c;)u=A.val&A.position,A.position>>=1,0==A.position&&(A.position=n,A.val=e(A.index++)),p|=(u>0?1:0)*a,a<<=1;f[d++]=r(p),l=d-1,h--;break;case 2:return w.join("")}if(0==h&&(h=Math.pow(2,m),m++),f[l])v=f[l];else{if(l!==d)return null;v=s+s.charAt(0)}w.push(v),f[d++]=s+v.charAt(0),h--,s=v,0==h&&(h=Math.pow(2,m),m++)}}};return i}();"function"==typeof define&&define.amd?define(function(){return LZString}):"undefined"!=typeof module&&null!=module&&(module.exports=LZString); +const EXCALIDRAW_PACKAGES = "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";const {react, reactDOM, excalidrawLib} = window.eval.call(window, `(function() {${LZString.decompressFromBase64(EXCALIDRAW_PACKAGES)};return {react:React, reactDOM:ReactDOM, excalidrawLib: ExcalidrawLib};})();`);const PLUGIN_VERSION="1.7.7";function _interopNamespace(A){if(A&&A.__esModule)return A;var e=Object.create(null);return A&&Object.keys(A).forEach((function(t){if("default"!==t){var i=Object.getOwnPropertyDescriptor(A,t);Object.defineProperty(e,t,i.get?i:{enumerable:!0,get:function(){return A[t]}})}})),e.default=A,Object.freeze(e)}var React__namespace=_interopNamespace(React);let random=A=>crypto.getRandomValues(new Uint8Array(A)),customRandom=(A,e,t)=>{let i=(2<{let s="";for(;;){let e=t(n),r=n;for(;r--;)if(s+=A[e[r]&i]||"",s.length===a)return s}}},customAlphabet=(A,e=21)=>customRandom(A,e,random);function JSON_parse(A){return JSON.parse(A.replaceAll("[","["))}const isDarwin=/Mac|iPod|iPhone|iPad/.test(window.navigator.platform),CTRL_OR_CMD=isDarwin?"metaKey":"ctrlKey",nanoid=customAlphabet("1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",8),KEYCODE={ESC:27},PLUGIN_ID="obsidian-excalidraw-plugin",SCRIPT_INSTALL_CODEBLOCK="excalidraw-script-install",SCRIPT_INSTALL_FOLDER="Downloaded",fileid=customAlphabet("1234567890abcdef",40),REG_LINKINDEX_INVALIDCHARS=/[<>:"\\|?*#]/g,REG_BLOCK_REF_CLEAN=/\+|\/|~|=|%|\(|\)|{|}|,|&|\.|\$|!|\?|;|\[|]|\^|#|\*|<|>|&|@|\||\\|"|:|\s/g,IMAGE_TYPES=["jpeg","jpg","png","gif","svg"],MAX_IMAGE_SIZE=500,FRONTMATTER_KEY="excalidraw-plugin",FRONTMATTER_KEY_EXPORT_TRANSPARENT="excalidraw-export-transparent",FRONTMATTER_KEY_EXPORT_DARK="excalidraw-export-dark",FRONTMATTER_KEY_EXPORT_SVGPADDING="excalidraw-export-svgpadding",FRONTMATTER_KEY_EXPORT_PNGSCALE="excalidraw-export-pngscale",FRONTMATTER_KEY_CUSTOM_PREFIX="excalidraw-link-prefix",FRONTMATTER_KEY_CUSTOM_URL_PREFIX="excalidraw-url-prefix",FRONTMATTER_KEY_CUSTOM_LINK_BRACKETS="excalidraw-link-brackets",FRONTMATTER_KEY_ONLOAD_SCRIPT="excalidraw-onload-script",FRONTMATTER_KEY_LINKBUTTON_OPACITY="excalidraw-linkbutton-opacity",FRONTMATTER_KEY_DEFAULT_MODE="excalidraw-default-mode",FRONTMATTER_KEY_FONT="excalidraw-font",FRONTMATTER_KEY_FONTCOLOR="excalidraw-font-color",FRONTMATTER_KEY_BORDERCOLOR="excalidraw-border-color",FRONTMATTER_KEY_MD_STYLE="excalidraw-css",LOCAL_PROTOCOL="md://",VIEW_TYPE_EXCALIDRAW="excalidraw",ICON_NAME="excalidraw-icon",RERENDER_EVENT="excalidraw-embed-rerender",BLANK_DRAWING='{"type":"excalidraw","version":2,"source":"https://excalidraw.com","elements":[],"appState":{"gridSize":null,"viewBackgroundColor":"#ffffff"}}',DARK_BLANK_DRAWING='{"type":"excalidraw","version":2,"source":"https://excalidraw.com","elements":[],"appState":{"theme":"dark","gridSize":null,"viewBackgroundColor":"#ffffff"}}',FRONTMATTER=["---","","excalidraw-plugin: parsed","tags: [excalidraw]","","---","==⚠ Switch to EXCALIDRAW VIEW in the MORE OPTIONS menu of this document. ⚠==","",""].join("\n"),EMPTY_MESSAGE="Hit enter to create a new drawing",TEXT_DISPLAY_PARSED_ICON_NAME="quote-glyph",TEXT_DISPLAY_RAW_ICON_NAME="presentation",FULLSCREEN_ICON_NAME="fullscreen",SCRIPTENGINE_ICON_NAME="ScriptEngine",COLOR_NAMES=new Map;COLOR_NAMES.set("aliceblue","#f0f8ff"),COLOR_NAMES.set("antiquewhite","#faebd7"),COLOR_NAMES.set("aqua","#00ffff"),COLOR_NAMES.set("aquamarine","#7fffd4"),COLOR_NAMES.set("azure","#f0ffff"),COLOR_NAMES.set("beige","#f5f5dc"),COLOR_NAMES.set("bisque","#ffe4c4"),COLOR_NAMES.set("black","#000000"),COLOR_NAMES.set("blanchedalmond","#ffebcd"),COLOR_NAMES.set("blue","#0000ff"),COLOR_NAMES.set("blueviolet","#8a2be2"),COLOR_NAMES.set("brown","#a52a2a"),COLOR_NAMES.set("burlywood","#deb887"),COLOR_NAMES.set("cadetblue","#5f9ea0"),COLOR_NAMES.set("chartreuse","#7fff00"),COLOR_NAMES.set("chocolate","#d2691e"),COLOR_NAMES.set("coral","#ff7f50"),COLOR_NAMES.set("cornflowerblue","#6495ed"),COLOR_NAMES.set("cornsilk","#fff8dc"),COLOR_NAMES.set("crimson","#dc143c"),COLOR_NAMES.set("cyan","#00ffff"),COLOR_NAMES.set("darkblue","#00008b"),COLOR_NAMES.set("darkcyan","#008b8b"),COLOR_NAMES.set("darkgoldenrod","#b8860b"),COLOR_NAMES.set("darkgray","#a9a9a9"),COLOR_NAMES.set("darkgreen","#006400"),COLOR_NAMES.set("darkkhaki","#bdb76b"),COLOR_NAMES.set("darkmagenta","#8b008b"),COLOR_NAMES.set("darkolivegreen","#556b2f"),COLOR_NAMES.set("darkorange","#ff8c00"),COLOR_NAMES.set("darkorchid","#9932cc"),COLOR_NAMES.set("darkred","#8b0000"),COLOR_NAMES.set("darksalmon","#e9967a"),COLOR_NAMES.set("darkseagreen","#8fbc8f"),COLOR_NAMES.set("darkslateblue","#483d8b"),COLOR_NAMES.set("darkslategray","#2f4f4f"),COLOR_NAMES.set("darkturquoise","#00ced1"),COLOR_NAMES.set("darkviolet","#9400d3"),COLOR_NAMES.set("deeppink","#ff1493"),COLOR_NAMES.set("deepskyblue","#00bfff"),COLOR_NAMES.set("dimgray","#696969"),COLOR_NAMES.set("dodgerblue","#1e90ff"),COLOR_NAMES.set("firebrick","#b22222"),COLOR_NAMES.set("floralwhite","#fffaf0"),COLOR_NAMES.set("forestgreen","#228b22"),COLOR_NAMES.set("fuchsia","#ff00ff"),COLOR_NAMES.set("gainsboro","#dcdcdc"),COLOR_NAMES.set("ghostwhite","#f8f8ff"),COLOR_NAMES.set("gold","#ffd700"),COLOR_NAMES.set("goldenrod","#daa520"),COLOR_NAMES.set("gray","#808080"),COLOR_NAMES.set("green","#008000"),COLOR_NAMES.set("greenyellow","#adff2f"),COLOR_NAMES.set("honeydew","#f0fff0"),COLOR_NAMES.set("hotpink","#ff69b4"),COLOR_NAMES.set("indianred","#cd5c5c"),COLOR_NAMES.set("indigo","#4b0082"),COLOR_NAMES.set("ivory","#fffff0"),COLOR_NAMES.set("khaki","#f0e68c"),COLOR_NAMES.set("lavender","#e6e6fa"),COLOR_NAMES.set("lavenderblush","#fff0f5"),COLOR_NAMES.set("lawngreen","#7cfc00"),COLOR_NAMES.set("lemonchiffon","#fffacd"),COLOR_NAMES.set("lightblue","#add8e6"),COLOR_NAMES.set("lightcoral","#f08080"),COLOR_NAMES.set("lightcyan","#e0ffff"),COLOR_NAMES.set("lightgoldenrodyellow","#fafad2"),COLOR_NAMES.set("lightgrey","#d3d3d3"),COLOR_NAMES.set("lightgreen","#90ee90"),COLOR_NAMES.set("lightpink","#ffb6c1"),COLOR_NAMES.set("lightsalmon","#ffa07a"),COLOR_NAMES.set("lightseagreen","#20b2aa"),COLOR_NAMES.set("lightskyblue","#87cefa"),COLOR_NAMES.set("lightslategray","#778899"),COLOR_NAMES.set("lightsteelblue","#b0c4de"),COLOR_NAMES.set("lightyellow","#ffffe0"),COLOR_NAMES.set("lime","#00ff00"),COLOR_NAMES.set("limegreen","#32cd32"),COLOR_NAMES.set("linen","#faf0e6"),COLOR_NAMES.set("magenta","#ff00ff"),COLOR_NAMES.set("maroon","#800000"),COLOR_NAMES.set("mediumaquamarine","#66cdaa"),COLOR_NAMES.set("mediumblue","#0000cd"),COLOR_NAMES.set("mediumorchid","#ba55d3"),COLOR_NAMES.set("mediumpurple","#9370d8"),COLOR_NAMES.set("mediumseagreen","#3cb371"),COLOR_NAMES.set("mediumslateblue","#7b68ee"),COLOR_NAMES.set("mediumspringgreen","#00fa9a"),COLOR_NAMES.set("mediumturquoise","#48d1cc"),COLOR_NAMES.set("mediumvioletred","#c71585"),COLOR_NAMES.set("midnightblue","#191970"),COLOR_NAMES.set("mintcream","#f5fffa"),COLOR_NAMES.set("mistyrose","#ffe4e1"),COLOR_NAMES.set("moccasin","#ffe4b5"),COLOR_NAMES.set("navajowhite","#ffdead"),COLOR_NAMES.set("navy","#000080"),COLOR_NAMES.set("oldlace","#fdf5e6"),COLOR_NAMES.set("olive","#808000"),COLOR_NAMES.set("olivedrab","#6b8e23"),COLOR_NAMES.set("orange","#ffa500"),COLOR_NAMES.set("orangered","#ff4500"),COLOR_NAMES.set("orchid","#da70d6"),COLOR_NAMES.set("palegoldenrod","#eee8aa"),COLOR_NAMES.set("palegreen","#98fb98"),COLOR_NAMES.set("paleturquoise","#afeeee"),COLOR_NAMES.set("palevioletred","#d87093"),COLOR_NAMES.set("papayawhip","#ffefd5"),COLOR_NAMES.set("peachpuff","#ffdab9"),COLOR_NAMES.set("peru","#cd853f"),COLOR_NAMES.set("pink","#ffc0cb"),COLOR_NAMES.set("plum","#dda0dd"),COLOR_NAMES.set("powderblue","#b0e0e6"),COLOR_NAMES.set("purple","#800080"),COLOR_NAMES.set("rebeccapurple","#663399"),COLOR_NAMES.set("red","#ff0000"),COLOR_NAMES.set("rosybrown","#bc8f8f"),COLOR_NAMES.set("royalblue","#4169e1"),COLOR_NAMES.set("saddlebrown","#8b4513"),COLOR_NAMES.set("salmon","#fa8072"),COLOR_NAMES.set("sandybrown","#f4a460"),COLOR_NAMES.set("seagreen","#2e8b57"),COLOR_NAMES.set("seashell","#fff5ee"),COLOR_NAMES.set("sienna","#a0522d"),COLOR_NAMES.set("silver","#c0c0c0"),COLOR_NAMES.set("skyblue","#87ceeb"),COLOR_NAMES.set("slateblue","#6a5acd"),COLOR_NAMES.set("slategray","#708090"),COLOR_NAMES.set("snow","#fffafa"),COLOR_NAMES.set("springgreen","#00ff7f"),COLOR_NAMES.set("steelblue","#4682b4"),COLOR_NAMES.set("tan","#d2b48c"),COLOR_NAMES.set("teal","#008080"),COLOR_NAMES.set("thistle","#d8bfd8"),COLOR_NAMES.set("tomato","#ff6347"),COLOR_NAMES.set("turquoise","#40e0d0"),COLOR_NAMES.set("violet","#ee82ee"),COLOR_NAMES.set("wheat","#f5deb3"),COLOR_NAMES.set("white","#ffffff"),COLOR_NAMES.set("whitesmoke","#f5f5f5"),COLOR_NAMES.set("yellow","#ffff00"),COLOR_NAMES.set("yellowgreen","#9acd32");const DEFAULT_MD_EMBED_CSS='.excalidraw-md-host{padding:0px 10px}.excalidraw-md-footer{height:5px}foreignObject{background-color:transparent}p{display:block;margin-block-start:1em;margin-block-end:1em;margin-inline-start:0px;margin-inline-end:0px;color:inherit}table,tr,th,td{color:inherit;border:1px solid;border-collapse:collapse;padding:3px}th{font-weight:bold;border-bottom:double;background-color:silver}.copy-code-button{display:none}code[class*=language-],pre[class*=language-]{color:#393a34;font-family:"Consolas","Bitstream Vera Sans Mono","Courier New",Courier,monospace;direction:ltr;text-align:left;white-space:pre;word-spacing:normal;word-break:normal;font-size:.9em;line-height:1.2em;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-hyphens:none;-moz-hyphens:none;-ms-hyphens:none;hyphens:none}pre>code[class*=language-]{font-size:1em}pre[class*=language-]::-moz-selection,pre[class*=language-] ::-moz-selection,code[class*=language-]::-moz-selection,code[class*=language-] ::-moz-selection{background:#C1DEF1}pre[class*=language-]::selection,pre[class*=language-] ::selection,code[class*=language-]::selection,code[class*=language-] ::selection{background:#C1DEF1}pre[class*=language-]{padding:1em;margin:.5em 0;overflow:auto;background-color:#0000001a}:not(pre)>code[class*=language-]{padding:.2em;padding-top:1px;padding-bottom:1px;background:#f8f8f8;border:1px solid #dddddd}.token.comment,.token.prolog,.token.doctype,.token.cdata{color:green;font-style:italic}.token.namespace{opacity:.7}.token.string{color:#a31515}.token.punctuation,.token.operator{color:#393a34}.token.url,.token.symbol,.token.number,.token.boolean,.token.variable,.token.constant,.token.inserted{color:#36acaa}.token.atrule,.token.keyword,.token.attr-value,.language-autohotkey .token.selector,.language-json .token.boolean,.language-json .token.number,code[class*=language-css]{color:#00f}.token.function{color:#393a34}.token.deleted,.language-autohotkey .token.tag{color:#9a050f}.token.selector,.language-autohotkey .token.keyword{color:#00009f}.token.important{color:#e90}.token.important,.token.bold{font-weight:bold}.token.italic{font-style:italic}.token.class-name,.language-json .token.property{color:#2b91af}.token.tag,.token.selector{color:maroon}.token.attr-name,.token.property,.token.regex,.token.entity{color:red}.token.directive.tag .tag{background:#ffff00;color:#393a34}.line-numbers.line-numbers .line-numbers-rows{border-right-color:#a5a5a5}.line-numbers .line-numbers-rows>span:before{color:#2b91af}.line-highlight.line-highlight{background:rgba(193,222,241,.2);background:-webkit-linear-gradient(left,rgba(193,222,241,.2) 70%,rgba(221,222,241,0));background:linear-gradient(to right,rgba(193,222,241,.2) 70%,rgba(221,222,241,0))}blockquote{ font-style:italic;background-color:rgb(46,43,42,0.1);margin:0;margin-left:1em;border-radius:0 4px 4px 0;border:1px solid hsl(0,80%,32%);border-left-width:8px;border-top-width:0px;border-right-width:0px;border-bottom-width:0px;padding:10px 20px;margin-inline-start:30px;margin-inline-end:30px;}',SCRIPTENGINE_ICON='',DISK_ICON_NAME="disk",DISK_ICON='',PNG_ICON_NAME="save-png",PNG_ICON='',SVG_ICON_NAME="save-svg",SVG_ICON='',EXCALIDRAW_ICON='',VIRGIL_DATAURL="data:application/font-woff;charset=utf-8;base64,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",VIRGIL_FONT=` @font-face {font-family: "Virgil";src: url("${VIRGIL_DATAURL}") format("woff2");}`,CASCADIA_FONT=' @font-face {font-family: "Cascadia";src: url("data:application/font-woff;charset=utf-8;base64,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") format("woff2");}';var commonjsGlobal="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},lzString={exports:{}};function splitFolderAndFilename(A){const e=A.lastIndexOf("/"),t=-1==e?A:A.substring(e+1);return{folderpath:obsidian.normalizePath(A.substring(0,e)),filename:t,basename:t.replace(/\.[^/.]+$/,"")}}function download(A,e,t){const i=document.createElement("a");i.setAttribute("href",(A?`${A},`:"")+e),i.setAttribute("download",t),i.style.display="none",document.body.appendChild(i),i.click(),document.body.removeChild(i)}function getIMGPathFromExcalidrawFile(A,e){const t=A.endsWith(".excalidraw")?".excalidraw":".md";return A.substring(0,A.lastIndexOf(t))+e}function getNewUniqueFilepath(A,e,t){let i=obsidian.normalizePath(`${t}/${e}`),n=A.getAbstractFileByPath(i),a=0;const s=e.endsWith(".excalidraw.md")?".excalidraw.md":e.slice(e.lastIndexOf("."));for(;n;)i=obsidian.normalizePath(`${t}/${e.slice(0,e.lastIndexOf(s))}_${a}${s}`),a++,n=A.getAbstractFileByPath(i);return i}function getDrawingFilename(A){return A.drawingFilenamePrefix+(""!==A.drawingFilenameDateTime?window.moment().format(A.drawingFilenameDateTime):"")+(A.compatibilityMode?".excalidraw":A.useExcalidrawExtension?".excalidraw.md":".md")}function getEmbedFilename(A,e){return(e.drawingEmbedPrefixWithFilename?A:"")+e.drawingFilnameEmbedPostfix+(""!==e.drawingFilenameDateTime?window.moment().format(e.drawingFilenameDateTime):"")+(e.compatibilityMode?".excalidraw":e.useExcalidrawExtension?".excalidraw.md":".md")}async function checkAndCreateFolder(A,e){e=obsidian.normalizePath(e);const t=A.getAbstractFileByPathInsensitive(e);t&&t instanceof obsidian.TFolder||(t&&t instanceof obsidian.TFile&&new obsidian.Notice(`The folder cannot be created because it already exists as a file: ${e}.`),await A.createFolder(e))}function getIMGFilename(A,e){return`${A.substring(0,A.lastIndexOf("."))}.${e}`}!function(A){var e=function(){var A=String.fromCharCode,e="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",t="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$",i={};function n(A,e){if(!i[A]){i[A]={};for(var t=0;t>>8,t[2*i+1]=s%256}return t},decompressFromUint8Array:function(e){if(null==e)return a.decompress(e);for(var t=new Array(e.length/2),i=0,n=t.length;i>=1}else{for(n=1,i=0;i>=1}0==--d&&(d=Math.pow(2,g),g++),delete r[c]}else for(n=s[c],i=0;i>=1;0==--d&&(d=Math.pow(2,g),g++),s[l]=h++,c=String(o)}if(""!==c){if(Object.prototype.hasOwnProperty.call(r,c)){if(c.charCodeAt(0)<256){for(i=0;i>=1}else{for(n=1,i=0;i>=1}0==--d&&(d=Math.pow(2,g),g++),delete r[c]}else for(n=s[c],i=0;i>=1;0==--d&&(d=Math.pow(2,g),g++)}for(n=2,i=0;i>=1;for(;;){if(w<<=1,p==e-1){u.push(t(w));break}p++}return u.join("")},decompress:function(A){return null==A?"":""==A?null:a._decompress(A.length,32768,(function(e){return A.charCodeAt(e)}))},_decompress:function(e,t,i){var n,a,s,r,o,l,c,d=[],h=4,g=4,u=3,w="",p=[],B={val:i(0),position:t,index:1};for(n=0;n<3;n+=1)d[n]=n;for(s=0,o=Math.pow(2,2),l=1;l!=o;)r=B.val&B.position,B.position>>=1,0==B.position&&(B.position=t,B.val=i(B.index++)),s|=(r>0?1:0)*l,l<<=1;switch(s){case 0:for(s=0,o=Math.pow(2,8),l=1;l!=o;)r=B.val&B.position,B.position>>=1,0==B.position&&(B.position=t,B.val=i(B.index++)),s|=(r>0?1:0)*l,l<<=1;c=A(s);break;case 1:for(s=0,o=Math.pow(2,16),l=1;l!=o;)r=B.val&B.position,B.position>>=1,0==B.position&&(B.position=t,B.val=i(B.index++)),s|=(r>0?1:0)*l,l<<=1;c=A(s);break;case 2:return""}for(d[3]=c,a=c,p.push(c);;){if(B.index>e)return"";for(s=0,o=Math.pow(2,u),l=1;l!=o;)r=B.val&B.position,B.position>>=1,0==B.position&&(B.position=t,B.val=i(B.index++)),s|=(r>0?1:0)*l,l<<=1;switch(c=s){case 0:for(s=0,o=Math.pow(2,8),l=1;l!=o;)r=B.val&B.position,B.position>>=1,0==B.position&&(B.position=t,B.val=i(B.index++)),s|=(r>0?1:0)*l,l<<=1;d[g++]=A(s),c=g-1,h--;break;case 1:for(s=0,o=Math.pow(2,16),l=1;l!=o;)r=B.val&B.position,B.position>>=1,0==B.position&&(B.position=t,B.val=i(B.index++)),s|=(r>0?1:0)*l,l<<=1;d[g++]=A(s),c=g-1,h--;break;case 2:return p.join("")}if(0==h&&(h=Math.pow(2,u),u++),d[c])w=d[c];else{if(c!==g)return null;w=a+a.charAt(0)}p.push(w),d[g++]=a+w.charAt(0),a=w,0==--h&&(h=Math.pow(2,u),u++)}}};return a}();null!=A&&(A.exports=e)}(lzString);const{exportToSvg:exportToSvg,exportToBlob:exportToBlob}=excalidrawLib;let versionUpdateChecked=!1;const checkExcalidrawVersion=async A=>{if(!versionUpdateChecked){versionUpdateChecked=!0;try{const A=async()=>JSON.parse(await obsidian.request({url:"https://api.github.com/repos/zsviczian/obsidian-excalidraw-plugin/releases?per_page=5&page=1"})),e=(await A()).map((A=>({version:A.tag_name,published:new Date(A.published_at)}))).filter((A=>A.version.match(/^\d+\.\d+\.\d+$/))).sort(((A,e)=>e.published-A.published))[0].version;e>PLUGIN_VERSION&&new obsidian.Notice(`A newer version of Excalidraw is available in Community Plugins.\n\nYou are using ${PLUGIN_VERSION}.\nThe latest is ${e}`)}catch(A){errorlog({where:"Utils/checkExcalidrawVersion",error:A})}setTimeout((()=>versionUpdateChecked=!1),288e5)}};function wrapText(A,e,t=!1,i=0){if(!e)return A;let n="";if(t){for(const t of A.split("\n")){const A=t.match(new RegExp(`(.){1,${e}}`,"g"));n+=A?`${A.join("\n")}\n`:"\n"}return n.replace(/\n$/,"")}const a=new RegExp(`(.{1,${e}})(\\s+|$\\n?)|([^\\s]{1,${e+i}})(\\s+|$\\n?)?`,"gm"),s=A.matchAll(a);let r;for(;!(r=s.next()).done;){n+=r.value[1]?r.value[1].trimEnd():r.value[3].trimEnd();const A=(r.value[2]?r.value[2].split("\n").length-1:0)+(r.value[4]?r.value[4].split("\n").length-1:0);n+="\n".repeat(A),0===A&&(n+="\n")}return n.replace(/\n$/,"")}const rotate=(A,e,t,i,n)=>[(A-t)*Math.cos(n)-(e-i)*Math.sin(n)+t,(A-t)*Math.sin(n)+(e-i)*Math.cos(n)+i],rotatedDimensions=A=>{if(0===A.angle)return[A.x,A.y,A.width,A.height];const e=A.x+A.width/2,t=A.y+A.height/2,[i,n]=rotate(A.x,A.y,e,t,A.angle),[a,s]=rotate(A.x+A.width,A.y+A.height,e,t,A.angle);return[i{const r=1/t.value;return{x:(A-i)*r-a,y:(e-n)*r-s}},getDataURL=async(A,e)=>new Promise(((t,i)=>{const n=new FileReader;n.onload=()=>{const A=n.result;t(A)},n.onerror=A=>i(A),n.readAsDataURL(new Blob([new Uint8Array(A)],{type:e}))})),getFontDataURL=async(A,e,t,i)=>{let n="",a="",s="";const r=A.metadataCache.getFirstLinkpathDest(e,t);if(r){const e=await A.vault.readBinary(r),t=r.extension.startsWith("woff")?"application/font-woff":"font/truetype";a=null!=i?i:r.basename,s=await getDataURL(e,t),n=` @font-face {font-family: "${a}";src: url("${s}") format("${"ttf"===r.extension?"truetype":r.extension}");}`;const o=n.split(";base64,",2);n=`${o[0]};charset=utf-8;base64,${o[1]}`}return{fontDef:n,fontName:a,dataURL:s}},svgToBase64=A=>`data:image/svg+xml;base64,${btoa(unescape(encodeURIComponent(A.replaceAll(" "," "))))}`,getBinaryFileFromDataURL=A=>{if(!A)return null;const e=A.matchAll(/base64,(.*)/g).next(),t=window.atob(e.value[1]),i=t.length,n=new Uint8Array(i);for(let A=0;A{var i;try{return await exportToSvg({elements:A.elements,appState:Object.assign({exportBackground:e.withBackground,exportWithDarkMode:!!e.withTheme&&"light"!=(null===(i=A.appState)||void 0===i?void 0:i.theme)},A.appState),files:A.files,exportPadding:t})}catch(A){return null}},getPNG=async(A,e,t=1)=>{var i;try{return await exportToBlob({elements:A.elements,appState:Object.assign({exportBackground:e.withBackground,exportWithDarkMode:!!e.withTheme&&"light"!=(null===(i=A.appState)||void 0===i?void 0:i.theme)},A.appState),files:A.files,mimeType:"image/png",getDimensions:(A,e)=>({width:A*t,height:e*t,scale:t})})}catch(A){return errorlog({where:"Utils.getPNG",error:A}),null}},getQuickImagePreview=async(A,e,t)=>{if(!A.settings.displayExportedImageIfAvailable)return null;const i=getIMGFilename(e,t),n=A.app.vault.getAbstractFileByPath(i);return n&&n instanceof obsidian.TFile?"png"===t?await A.app.vault.readBinary(n):await A.app.vault.read(n):null},embedFontsInSVG=(A,e)=>{const t=null!=A.querySelector("text[font-family^='Virgil']"),i=null!=A.querySelector("text[font-family^='Cascadia']"),n=null!=A.querySelector("text[font-family^='LocalFont']"),a=A.querySelector("defs");return a&&(i||t||n)&&(a.innerHTML=``),A},getImageSize=async A=>new Promise(((e,t)=>{const i=new Image;i.onload=()=>e({height:i.height,width:i.width}),i.onerror=t,i.src=A})),scaleLoadedImage=(A,e)=>{let t=!1;if(!e||!A)return{dirty:t,scene:A};for(const i of e){const[e,n]=[i.size.width,i.size.height],a=i.size.width/i.size.height;return A.elements.filter((A=>"image"===A.type&&A.fileId===i.id)).forEach((A=>{const[i,s]=[A.width,A.height];if(a!=i/s){t=!0;const a=Math.sqrt(i*s*n/e),r=Math.sqrt(i*s*e/n);A.height=a,A.width=r,A.y+=(s-a)/2,A.x+=(i-r)/2}})),{dirty:t,scene:A}}},setLeftHandedMode=A=>{const e=new Set;app.workspace.iterateAllLeaves((t=>{const i=app.isMobile?document:t.view.containerEl.ownerDocument;if(!i)return;if(e.has(i))return;e.add(i);const n=i.createElement("style");n.id="excalidraw-letf-handed",n.textContent=".excalidraw .App-bottom-bar{justify-content:flex-end;}";const a=i.getElementById(n.id);a&&i.head.removeChild(a),A&&i.head.appendChild(n)}))},getLinkParts=(A,e)=>{var t;const i=A.match(/(^[^#\|]*)#?(\^)?([^\|]*)?\|?(\d*)x?(\d*)/);return{original:A,path:e&&""===i[1]?e.path:i[1],isBlockRef:"^"===i[2],ref:null===(t=i[3])||void 0===t?void 0:t.replaceAll(REG_BLOCK_REF_CLEAN,""),width:i[4]?parseInt(i[4]):void 0,height:i[5]?parseInt(i[5]):void 0}},compress=A=>lzString.exports.compressToBase64(A).replace(/(.{64})/g,"$1\n\n"),decompress=A=>lzString.exports.decompressFromBase64(A.replaceAll("\n","").replaceAll("\r","")),hasExportTheme=(A,e)=>{if(e){const t=A.app.metadataCache.getFileCache(e);if((null==t?void 0:t.frontmatter)&&null!=t.frontmatter["excalidraw-export-dark"])return!0}return!1},getExportTheme=(A,e,t)=>{if(e){const t=A.app.metadataCache.getFileCache(e);if((null==t?void 0:t.frontmatter)&&null!=t.frontmatter["excalidraw-export-dark"])return t.frontmatter["excalidraw-export-dark"]?"dark":"light"}return A.settings.exportWithTheme?t:"light"},hasExportBackground=(A,e)=>{if(e){const t=A.app.metadataCache.getFileCache(e);if((null==t?void 0:t.frontmatter)&&null!=t.frontmatter["excalidraw-export-transparent"])return!0}return!1},getWithBackground=(A,e)=>{if(e){const t=A.app.metadataCache.getFileCache(e);if((null==t?void 0:t.frontmatter)&&null!=t.frontmatter["excalidraw-export-transparent"])return!t.frontmatter["excalidraw-export-transparent"]}return A.settings.exportWithBackground},getSVGPadding=(A,e)=>{if(e){const t=A.app.metadataCache.getFileCache(e);if((null==t?void 0:t.frontmatter)&&null!=t.frontmatter["excalidraw-export-svgpadding"]){const A=parseInt(t.frontmatter["excalidraw-export-svgpadding"]);if(!isNaN(A))return A}}return A.settings.exportPaddingSVG},getPNGScale=(A,e)=>{if(e){const t=A.app.metadataCache.getFileCache(e);if((null==t?void 0:t.frontmatter)&&null!=t.frontmatter["excalidraw-export-pngscale"]){const A=parseFloat(t.frontmatter["excalidraw-export-pngscale"]);if(!isNaN(A)&&A>0)return A}}return A.settings.pngExportScale},errorlog=A=>{console.error(Object.assign({plugin:"Excalidraw"},A))},sleep$1=async A=>new Promise((e=>setTimeout(e,A))),log=console.log.bind(window.console);console.log.bind(window.console);const getParentOfClass=(A,e)=>{var t;let i=A.parentElement;for(;i&&!(i instanceof window.HTMLBodyElement)&&!i.classList.contains(e);)i=i.parentElement;return(null===(t=null==i?void 0:i.classList)||void 0===t?void 0:t.contains(e))?i:null},getNewOrAdjacentLeaf=(A,e)=>{if(A.settings.openInMainWorkspace){e.view.navigation=!1;const t=app.workspace.getLeaf(!1);return e.view.navigation=!0,A.settings.openInAdjacentPane||"empty"===t.view.getViewType()?t:app.workspace.createLeafBySplit(t)}if(A.settings.openInAdjacentPane){if(e.view.containerEl.ownerDocument!==document){const A=new Set;return app.workspace.iterateAllLeaves((t=>{t!==e&&t.view.navigation&&t.view.containerEl.ownerDocument===e.view.containerEl.ownerDocument&&A.add(t)})),0===A.size?app.workspace.getLeaf(!0):Array.from(A)[0]}e.view.navigation=!1;const A=app.workspace.getLeaf(!1);return e.view.navigation=!0,A}return A.app.workspace.createLeafBySplit(e)},getAttachmentsFolderAndFilePath=async(A,e,t)=>{let i=A.vault.getConfig("attachmentFolderPath");if(i&&i.startsWith("./")){const A=`${splitFolderAndFilename(e).folderpath}/`;i=obsidian.normalizePath(A+i.substring(2))}return i&&"/"!==i||(i=""),await checkAndCreateFolder(A.vault,i),{folder:i,filepath:obsidian.normalizePath(""===i?t:`${i}/${t}`)}},isObsidianThemeDark=()=>document.body.classList.contains("theme-dark");var ar={},cz={},da={},de={},en={INSTALL_SCRIPT:"Install this script",UPDATE_SCRIPT:"An update is available - Click to install",CHECKING_SCRIPT:"Checking if a newer version is available - Click to reinstall now",UNABLETOCHECK_SCRIPT:"Update check was unsuccessful - Click to reinstall now",UPTODATE_SCRIPT:"Script is installed and up to date - Click to reinstall now",OPEN_AS_EXCALIDRAW:"Open as Excalidraw Drawing",TOGGLE_MODE:"Toggle between Excalidraw and Markdown mode",CONVERT_NOTE_TO_EXCALIDRAW:"Convert empty note to Excalidraw Drawing",CONVERT_EXCALIDRAW:"Convert *.excalidraw to *.md files",CREATE_NEW:"New Excalidraw drawing",CONVERT_FILE_KEEP_EXT:"*.excalidraw => *.excalidraw.md",CONVERT_FILE_REPLACE_EXT:"*.excalidraw => *.md (Logseq compatibility)",DOWNLOAD_LIBRARY:"Export stencil library as an *.excalidrawlib file",OPEN_EXISTING_NEW_PANE:"Open an existing drawing - IN A NEW PANE",OPEN_EXISTING_ACTIVE_PANE:"Open an existing drawing - IN THE CURRENT ACTIVE PANE",TRANSCLUDE:"Transclude (embed) a drawing",TRANSCLUDE_MOST_RECENT:"Transclude (embed) the most recently edited drawing",NEW_IN_NEW_PANE:"Create a new drawing - IN A NEW PANE",NEW_IN_ACTIVE_PANE:"Create a new drawing - IN THE CURRENT ACTIVE PANE",NEW_IN_POPOUT_WINDOW:"Create a new drawing - IN A POPOUT WINDOW",NEW_IN_NEW_PANE_EMBED:"Create a new drawing - IN A NEW PANE - and embed into active document",NEW_IN_ACTIVE_PANE_EMBED:"Create a new drawing - IN THE CURRENT ACTIVE PANE - and embed into active document",NEW_IN_POPOUT_WINDOW_EMBED:"Create a new drawing - IN A POPOUT WINDOW - and embedd into active document",EXPORT_SVG:"Save as SVG next to the current file",EXPORT_PNG:"Save as PNG next to the current file",TOGGLE_LOCK:"Toggle Text Element edit RAW/PREVIEW",DELETE_FILE:"Delete selected Image or Markdown file from Obsidian Vault",INSERT_LINK_TO_ELEMENT:"Copy markdown link for selected element to clipboard",INSERT_LINK_TO_ELEMENT_ERROR:"Select a single element in the scene",INSERT_LINK_TO_ELEMENT_READY:"Link is READY and available on the clipboard",INSERT_LINK:"Insert link to file",INSERT_IMAGE:"Insert image from vault",INSERT_MD:"Insert markdown file from vault",INSERT_LATEX:"Insert LaTeX formula (e.g. \\binom{n}{k} = \\frac{n!}{k!(n-k)!})",ENTER_LATEX:"Enter a valid LaTeX expression",READ_RELEASE_NOTES:"Read latest release notes",TRAY_MODE:"Toggle property-panel tray-mode",SEARCH:"Search for text in drawing",INSTALL_SCRIPT_BUTTON:"Install or update Excalidraw Scripts",OPEN_AS_MD:"Open as Markdown",SAVE_AS_PNG:"Save as PNG into Vault (CTRL/CMD+CLICK to export)",SAVE_AS_SVG:"Save as SVG into Vault (CTRL/CMD+CLICK to export)",OPEN_LINK:"Open selected text as link\n(SHIFT+CLICK to open in a new pane)",EXPORT_EXCALIDRAW:"Export to an .Excalidraw file",LINK_BUTTON_CLICK_NO_TEXT:"Select a an ImageElement, or select a TextElement that contains an internal or external link.\nSHIFT CLICK this button to open the link in a new pane.\nCTRL/CMD CLICK the Image or TextElement on the canvas has the same effect!",FILENAME_INVALID_CHARS:'File name cannot contain any of the following characters: * " \\ < > : | ? #',FILE_DOES_NOT_EXIST:"File does not exist. Hold down ALT (or ALT+SHIFT) and CLICK link button to create a new file.",FORCE_SAVE:"Force-save to update transclusions in adjacent panes.\n(Check autosave settings in plugin settings.)",RAW:"Change to PREVIEW mode (only effects text-elements with links or transclusions)",PARSED:"Change to RAW mode (only effects text-elements with links or transclusions)",NOFILE:"Excalidraw (no file)",COMPATIBILITY_MODE:"*.excalidraw file opened in compatibility mode. Convert to new format for full plugin functionality.",CONVERT_FILE:"Convert to new format",RELEASE_NOTES_NAME:"Display Release Notes after update",RELEASE_NOTES_DESC:"Toggle ON: Display release notes each time you update Excalidraw to a newer version.
Toggle OFF: Silent mode. You can still read release notes on GitHub.",FOLDER_NAME:"Excalidraw folder",FOLDER_DESC:"Default location for new drawings. If empty, drawings will be created in the Vault root.",FOLDER_EMBED_NAME:"Use Excalidraw folder when embedding a drawing into the active document",FOLDER_EMBED_DESC:"Define which folder to place the newly inserted drawing into when using the command palette action: 'Create a new drawing and embed into active document'. ON: Use Excalidraw folder; OFF: use attachments folder defined in Obsidian settings",TEMPLATE_NAME:"Excalidraw template file",TEMPLATE_DESC:"Full filepath to the Excalidraw template. E.g.: If your template is in the default Excalidraw folder and it's name is Template.md, the setting would be: Excalidraw/Template.md (or just Excalidraw/Template - you may omit the .md file extension). If you are using Excalidraw in compatibility mode, then your template must be a legacy Excalidraw file as well such as Excalidraw/Template.excalidraw.",SCRIPT_FOLDER_NAME:"Excalidraw Automate script folder",SCRIPT_FOLDER_DESC:"The files you place in this folder will be treated as Excalidraw Automate scripts. You can access your scripts from Excalidraw via the Obsidian Command Palette. Assign hotkeys to your favorite scripts just like to any other Obsidian command. The folder may not be the root folder of your Vault. ",COMPRESS_NAME:"Compress Excalidraw JSON in Markdown",COMPRESS_DESC:"By enabling this feature Excalidraw will store the drawing JSON in a Base64 compressed format using the LZ-String algorithm. This will reduce the chance of Excalidraw JSON cluttering your search results in Obsidian. As a side effect, this will also reduce the filesize of Excalidraw drawings. When you switch an Excalidraw drawing to Markdown view, using the options menu in Excalidraw, the file will be saved without compression, so that you can read and edit the JSON string. The drawing will be compressed again once you switch back to Excalidraw view. The setting only has effect 'point forward', meaning, existing drawings will not be effected by the setting until you open them and save them. ",AUTOSAVE_NAME:"Enable Autosave",AUTOSAVE_DESC:"Automatically save the active drawing, in case there are changes, every 15, 30 seconds, or 1, 2, 3, 4, or 5 minute. Save normally happens when you close Excalidraw or Obsidian, or move focus to another pane. I created this feature with mobile phones and tablets in mind, where 'swiping out Obsidian to close it' led to some data loss.",AUTOSAVE_INTERVAL_NAME:"Interval for autosave",AUTOSAVE_INTERVAL_DESC:"The time interval between saves. Autosave will skip if there are no changes in the drawing.",FILENAME_HEAD:"Filename",FILENAME_DESC:"

Click this link for the date and time format reference.

",FILENAME_SAMPLE:"Filename for a new drawing is: ",FILENAME_EMBED_SAMPLE:"Filename for a new embedded drawing is: ",FILENAME_PREFIX_NAME:"Filename prefix",FILENAME_PREFIX_DESC:"The first part of the filename",FILENAME_PREFIX_EMBED_NAME:"Filename prefix when embedding a new drawing into a markdown note",FILENAME_PREFIX_EMBED_DESC:"Should the filename of the newly inserted drawing start with the name of the active markdown note when using the command palette action: Create a new drawing and embed into active document? ON: Yes, OFF: Not",FILENAME_POSTFIX_NAME:"Custom text after markdown Note's name when embedding",FILENAME_POSTFIX_DESC:"Effects filename only when embedding into a markdown document. This is text will be inserted after the note's name, but before the date.",FILENAME_DATE_NAME:"Filename Date",FILENAME_DATE_DESC:"The last part of the filename. Leave empty if you do not want a date.",FILENAME_EXCALIDRAW_EXTENSION_NAME:".excalidraw.md or .md",FILENAME_EXCALIDRAW_EXTENSION_DESC:"This setting does not apply if you use Excalidraw in compatibility mode, i.e. you are not using Excalidraw markdown files. Toggle ON = filename ends with .excalidraw.md, Toggle OFF = filename ends with .md",DISPLAY_HEAD:"Display",LEFTHANDED_MODE_NAME:"Left-handed mode",LEFTHANDED_MODE_DESC:"Currently only has effect in tray-mode. If turned on, the tray will be on the right side.",MATCH_THEME_NAME:"New drawing to match Obsidian theme",MATCH_THEME_DESC:"If theme is dark, new drawing will be created in dark mode. This does not apply when you use a template for new drawings. Also this will not effect when you open an existing drawing. Those will follow the theme of the template/drawing respectively.",MATCH_THEME_ALWAYS_NAME:"Existing drawings to match Obsidian theme",MATCH_THEME_ALWAYS_DESC:"If theme is dark, drawings will be opened in dark mode. If your theme is light, they will be opened in light mode. ",MATCH_THEME_TRIGGER_NAME:"Excalidraw to follow when Obsidian Theme changes",MATCH_THEME_TRIGGER_DESC:"If this option is enabled open Excalidraw pane will switch to light/dark mode when Obsidian theme changes. ",DEFAULT_OPEN_MODE_NAME:"Default mode when opening Excalidraw",DEFAULT_OPEN_MODE_DESC:"Specifies the mode how Excalidraw opens: Normal, Zen, or View mode. You may also set this behavior on a file level by adding the excalidraw-default-mode frontmatter key with a value of: normal,view, or zen to your document.",DEFAULT_PEN_MODE_NAME:"Pen mode",DEFAULT_PEN_MODE_DESC:"Should pen mode be automatically enabled when opening Excalidraw?",ZOOM_TO_FIT_NAME:"Zoom to fit on view resize",ZOOM_TO_FIT_DESC:"Zoom to fit drawing when the pane is resized",ZOOM_TO_FIT_MAX_LEVEL_NAME:"Zoom to fit max ZOOM level",ZOOM_TO_FIT_MAX_LEVEL_DESC:"Set the maximum level to which zoom to fit will enlarge the drawing. Minimum is 0.5 (50%) and maximum is 10 (1000%).",LINKS_HEAD:"Links and transclusion",LINKS_DESC:"CTRL/CMD + CLICK on [[Text Elements]] to open them as links. If the selected text has more than one [[valid Obsidian links]], only the first will be opened. If the text starts as a valid web link (i.e. https:// or http://), then the plugin will open it in a browser. When Obsidian files change, the matching [[link]] in your drawings will also change. If you don't want text accidentally changing in your drawings use [[links|with aliases]].",ADJACENT_PANE_NAME:"Open in adjacent pane",ADJACENT_PANE_DESC:"When CTRL/CMD+SHIFT clicking a link in Excalidraw, by default the plugin will open the link in a new pane. Turning this setting on, Excalidraw will first look for an existing adjacent pane, and try to open the link there. Excalidraw will look for the adjacent pane based on your focus/navigation history, i.e. the workpane that was active before you activated Excalidraw.",MAINWORKSPACE_PANE_NAME:"Open in main workspace",MAINWORKSPACE_PANE_DESC:"When CTRL/CMD+SHIFT clicking a link in Excalidraw, by default the plugin will open the link in a new pane in the current active window. Turning this setting on, Excalidraw will open the link in an existing or new pane in the main workspace. ",LINK_BRACKETS_NAME:"Show [[brackets]] around links",LINK_BRACKETS_DESC:"In PREVIEW mode, when parsing Text Elements, place brackets around links. You can override this setting for a specific drawing by adding excalidraw-link-brackets: true/false to the file's frontmatter.",LINK_PREFIX_NAME:"Link prefix",LINK_PREFIX_DESC:'In PREVIEW mode, if the Text Element contains a link, precede the text with these characters. You can override this setting for a specific drawing by adding excalidraw-link-prefix: "📍 " to the file\'s frontmatter.',URL_PREFIX_NAME:"URL prefix",URL_PREFIX_DESC:'In PREVIEW mode, if the Text Element contains a URL link, precede the text with these characters. You can override this setting for a specific drawing by adding excalidraw-url-prefix: "🌐 " to the file\'s frontmatter.',HOVERPREVIEW_NAME:"Hover preview without CTRL/CMD key",HOVERPREVIEW_DESC:"Toggle On: In Exalidraw view mode the hover preview for [[wiki links]] will be shown immediately, without the need to hold the CTRL/CMD key. In Excalidraw normal mode, the preview will be shown immediately only when hovering the blue link icon in the top right of the element.
Toggle Off: Hover preview is shown only when you hold the CTRL/CMD key while hovering the link.",LINKOPACITY_NAME:"Opacity of link icon",LINKOPACITY_DESC:"Opacity of the link indicator icon in the top right corner of an element. 1 is opaque, 0 is transparent.",LINK_CTRL_CLICK_NAME:"CTRL/CMD + CLICK on text with [[links]] or [](links) to open them",LINK_CTRL_CLICK_DESC:"You can turn this feature off if it interferes with default Excalidraw features you want to use. If this is turned off, only the link button in the title bar of the drawing pane will open links.",TRANSCLUSION_WRAP_NAME:"Overflow wrap behavior of transcluded text",TRANSCLUSION_WRAP_DESC:"Number specifies the character count where the text should be wrapped. Set the text wrapping behavior of transcluded text. Turn this ON to force-wrap text (i.e. no overflow), or OFF to soft-wrap text (at the nearest whitespace).",TRANSCLUSION_DEFAULT_WRAP_NAME:"Transclusion word wrap default",TRANSCLUSION_DEFAULT_WRAP_DESC:"You can set manually set/override word wrapping length using the `![[page#^block]]{NUMBER}` format. Normally you will not want to set a default, because if you transclude text inside a sticky note, then Excalidraw will automatically take care of word wrapping. Set this value to `0` if you do not want to set a default. ",PAGE_TRANSCLUSION_CHARCOUNT_NAME:"Page transclusion max char count",PAGE_TRANSCLUSION_CHARCOUNT_DESC:"The maximum number of characters to display from the page when transcluding an entire page with the ![[markdown page]] format.",GET_URL_TITLE_NAME:"Use iframely to resolve page title",GET_URL_TITLE_DESC:"Use the http://iframely.server.crestify.com/iframely?url= to get title of page when dropping a link into Excalidraw",MD_HEAD:"Markdown-embed settings",MD_HEAD_DESC:"You can transclude formatted markdown documents into drawings as images CTRL(Shift on Mac) drop from the file explorer or using the command palette action.",MD_TRANSCLUDE_WIDTH_NAME:"Default width of a transcluded markdown document",MD_TRANSCLUDE_WIDTH_DESC:"The width of the markdown page. This effects the word wrapping when transcluding longer paragraphs, and the width of the image element. You can override the default width of an embedded file using the [[filename#heading|WIDTHxMAXHEIGHT]] syntax in markdown view mode under embedded files.",MD_TRANSCLUDE_HEIGHT_NAME:"Default maximum height of a transcluded markdown document",MD_TRANSCLUDE_HEIGHT_DESC:"The embedded image will be as high as the markdown text requires, but not higher than this value. You can override this value by editing the embedded image link in markdown view mode with the following syntax [[filename#^blockref|WIDTHxMAXHEIGHT]].",MD_DEFAULT_FONT_NAME:"The default font typeface to use for embedded markdown files.",MD_DEFAULT_FONT_DESC:'Set this value to "Virgil" or "Cascadia" or the filename of a valid .ttf, .woff, or .woff2 font e.g. MyFont.woff2 You can override this setting by adding the following frontmatter-key to the embedded markdown file: excalidraw-font: font_or_filename',MD_DEFAULT_COLOR_NAME:"The default font color to use for embedded markdown files.",MD_DEFAULT_COLOR_DESC:'Set this to any valid css color name e.g. "steelblue" (color names), or a valid hexadecimal color e.g. "#e67700", or any other valid css color string. You can override this setting by adding the following frontmatter-key to the embedded markdown file: excalidraw-font-color: steelblue',MD_DEFAULT_BORDER_COLOR_NAME:"The default border color to use for embedded markdown files.",MD_DEFAULT_BORDER_COLOR_DESC:'Set this to any valid css color name e.g. "steelblue" (color names), or a valid hexadecimal color e.g. "#e67700", or any other valid css color string. You can override this setting by adding the following frontmatter-key to the embedded markdown file: excalidraw-border-color: gray. Leave empty if you don\'t want a border. ',MD_CSS_NAME:"CSS file",MD_CSS_DESC:"The filename of the CSS to apply to markdown embeds. Provide the filename with extension (e.g. 'md-embed.css'). The css file may also be a plain markdown file (e.g. 'md-embed-css.md'), just make sure the content is written using valid css syntax. If you need to look at the HTML code you are applying the CSS to, then open Obsidian Developer Console (CTRL+SHIFT+i) and type in the following command: \"ExcalidrawAutomate.mostRecentMarkdownSVG\". This will display the most recent SVG generated by Excalidraw. Setting the font-family in the css is has limitations. By default only your operating system's standard fonts are available (see README for details). You can add one custom font beyond that using the setting above. You can override this css setting by adding the following frontmatter-key to the embedded markdown file: \"excalidraw-css: css_file_in_vault|css-snippet\".",EMBED_HEAD:"Embed & Export",EMBED_REUSE_EXPORTED_IMAGE_NAME:"If found, use the already exported image for preview",EMBED_REUSE_EXPORTED_IMAGE_DESC:"This setting works in conjunction with the Auto-export SVG/PNG setting. If an exported image that matches the file name of the drawing is available, use that image instead of generating a preview image on the fly. This will result in faster previews especially when you have many embedded objects in the drawing, however, it may happen that your latest changes are not displayed and that the image will not automatically match your Obsidian theme in case you have changed the Obsidian theme since the export was created. This setting only applies to embedding images into markdown documents. For a number of reasons, the same approach cannot be used to expedite the loading of drawings with many embedded objects. See demonstration here.",EMBED_PREVIEW_SVG_NAME:"Display SVG in markdown preview",EMBED_PREVIEW_SVG_DESC:"The default is to display drawings as SVG images in the markdown preview. Turning this feature off, the markdown preview will display the drawing as an embedded PNG image.",PREVIEW_MATCH_OBSIDIAN_NAME:"Excalidraw preview to match Obsidian theme",PREVIEW_MATCH_OBSIDIAN_DESC:"Image preview in documents should match the Obsidian theme. If enabled, when Obsidian is in dark mode, Excalidraw images will render in dark mode. When Obsidian is in light mode, Excalidraw will render light mode as well. You may want to switch 'Export image with background' off for a more Obsidian-integrated look and feel.",EMBED_WIDTH_NAME:"Default width of embedded (transcluded) image",EMBED_WIDTH_DESC:"The default width of an embedded drawing. This applies to live preview edit and reading mode, as well as to hover previews. You can specify a custom width when embedding an image using the ![[drawing.excalidraw|100]] or [[drawing.excalidraw|100x100]] format.",EMBED_TYPE_NAME:"Type of file to insert into the document",EMBED_TYPE_DESC:"When you embed an image into a document using the command palette this setting will specify if Excalidraw should embed the original Excalidraw file or a PNG or an SVG copy. You need to enable auto-export PNG / SVG (see below under Export Settings) for those image types to be available in the dropdown. For drawings that do not have a a corresponding PNG or SVG readily available the command palette action will insert a broken link. You need to open the original drawing and initiate export manually. This option will not autogenerate PNG/SVG files, but will simply reference the already existing files.",EMBED_WIKILINK_NAME:"Embed SVG or PNG as Wiki link",EMBED_WIKILINK_DESC:"Toggle ON: Excalidraw will embed a [[wiki link]]. Toggle OFF: Excalidraw will embed a [markdown](link).",EXPORT_PNG_SCALE_NAME:"PNG export image scale",EXPORT_PNG_SCALE_DESC:"The size-scale of the exported PNG image",EXPORT_BACKGROUND_NAME:"Export image with background",EXPORT_BACKGROUND_DESC:"If turned off, the exported image will be transparent.",EXPORT_SVG_PADDING_NAME:"SVG Padding",EXPORT_SVG_PADDING_DESC:"The padding (in pixels) around the exported SVG image. If you have curved lines close to the edge of the image they might get cropped during SVG export. You can increase this value to avoid cropping.",EXPORT_THEME_NAME:"Export image with theme",EXPORT_THEME_DESC:"Export the image matching the dark/light theme of your drawing. If turned off, drawings created in dark mode will appear as they would in light mode.",EXPORT_HEAD:"Export Settings",EXPORT_SYNC_NAME:"Keep the .SVG and/or .PNG filenames in sync with the drawing file",EXPORT_SYNC_DESC:"When turned on, the plugin will automatically update the filename of the .SVG and/or .PNG files when the drawing in the same folder (and same name) is renamed. The plugin will also automatically delete the .SVG and/or .PNG files when the drawing in the same folder (and same name) is deleted. ",EXPORT_SVG_NAME:"Auto-export SVG",EXPORT_SVG_DESC:"Automatically create an SVG export of your drawing matching the title of your file. The plugin will save the *.SVG file in the same folder as the drawing. Embed the .svg file into your documents instead of Excalidraw making you embeds platform independent. While the auto-export switch is on, this file will get updated every time you edit the Excalidraw drawing with the matching name.",EXPORT_PNG_NAME:"Auto-export PNG",EXPORT_PNG_DESC:"Same as the auto-export SVG, but for *.PNG",COMPATIBILITY_HEAD:"Compatibility features",EXPORT_EXCALIDRAW_NAME:"Auto-export Excalidraw",EXPORT_EXCALIDRAW_DESC:"Same as the auto-export SVG, but for *.Excalidraw",SYNC_EXCALIDRAW_NAME:"Sync *.excalidraw with *.md version of the same drawing",SYNC_EXCALIDRAW_DESC:"If the modified date of the *.excalidraw file is more recent than the modified date of the *.md file then update the drawing in the .md file based on the .excalidraw file",COMPATIBILITY_MODE_NAME:"New drawings as legacy files",COMPATIBILITY_MODE_DESC:"By enabling this feature drawings you create with the ribbon icon, the command palette actions, and the file explorer are going to be all legacy *.excalidraw files. This setting will also turn off the reminder message when you open a legacy file for editing.",MATHJAX_NAME:"MathJax (LaTeX) javascript library host",MATHJAX_DESC:"If you are using LaTeX equiations in Excalidraw then the plugin needs to load a javascript library for that. Some users are unable to access certain host servers. If you are experiencing issues try changing the host here. You may need to restart Obsidian after closing settings, for this change to take effect.",EXPERIMENTAL_HEAD:"Experimental features",EXPERIMENTAL_DESC:"Some of these setting will not take effect immediately, only when the File Explorer is refreshed, or Obsidian restarted.",FIELD_SUGGESTER_NAME:"Enable Field Suggester",FIELD_SUGGESTER_DESC:"Field Suggester borrowed from Breadcrumbs and Templater plugins. The Field Suggester will show an autocomplete menu when you type excalidraw- or ea. with function description as hints on the individual items in the list.",FILETYPE_NAME:"Display type (✏️) for excalidraw.md files in File Explorer",FILETYPE_DESC:"Excalidraw files will receive an indicator using the emoji or text defined in the next setting.",FILETAG_NAME:"Set the type indicator for excalidraw.md files",FILETAG_DESC:"The text or emoji to display as type indicator.",INSERT_EMOJI:"Insert an emoji",LIVEPREVIEW_NAME:"Immersive image embedding in live preview editing mode",LIVEPREVIEW_DESC:"Turn this on to support image embedding styles such as ![[drawing|width|style]] in live preview editing mode. The setting will not effect the currently open documents. You need close the open documents and re-open them for the change to take effect.",ENABLE_FOURTH_FONT_NAME:"Enable fourth font option",ENABLE_FOURTH_FONT_DESC:"By turning this on, you will see a fourth font button on the properties panel for text elements. Files that use this fourth font will (partly) lose their platform independence. Depending on the custom font set in settings, they will look differently when loaded in another vault, or at a later time. Also the 4th font will display as system default font on excalidraw.com, or other Excalidraw versions.",FOURTH_FONT_NAME:"Forth font file",FOURTH_FONT_DESC:"Select a .ttf, .woff or .woff2 font file from your vault to use as the fourth font. If no file is selected, Excalidraw will use the Virgil font by default.",SCRIPT_SETTINGS_HEAD:"Settings for installed Scripts",SELECT_FILE:"Select a file then press enter.",NO_MATCH:"No file matches your query.",SELECT_FILE_TO_LINK:"Select the file you want to insert the link for.",SELECT_DRAWING:"Select the drawing you want to insert",TYPE_FILENAME:"Type name of drawing to select.",SELECT_FILE_OR_TYPE_NEW:"Select existing drawing or type name of a new drawing then press Enter.",SELECT_TO_EMBED:"Select the drawing to insert into active document.",SELECT_MD:"Select the markdown document you want to insert",INFINITE_LOOP_WARNING:"EXCALIDRAW WARNING\nAborted loading embedded images due to infinite loop in file:\n",SCRIPT_EXECUTION_ERROR:"Script execution error. Please find error message on the developer console.",LOAD_FROM_BACKUP:"Excalidraw file was corrupted. Loading from backup file.",GOTO_FULLSCREEN:"Goto fullscreen mode",EXIT_FULLSCREEN:"Exit fullscreen mode",TOGGLE_FULLSCREEN:"Toggle fullscreen mode"},enGB={},es={},fr={},hi={},id={},it={},ja={},ko={},nl={},no={},pl={},pt={},ptBR={},ro={},ru={},tr={},zhCN={INSTALL_SCRIPT:"安装此脚本",UPDATE_SCRIPT:"发现可用更新 - 点击安装",CHECKING_SCRIPT:"检查脚本更新 - 点击重新安装",UNABLETOCHECK_SCRIPT:"检查更新失败 - 点击重新安装",UPTODATE_SCRIPT:"已安装最新脚本 - 点击重新安装",OPEN_AS_EXCALIDRAW:"打开为 Excalidraw 绘图（Excalidraw 模式）",TOGGLE_MODE:"在 Excalidraw 和 Markdown 模式之间切换",CONVERT_NOTE_TO_EXCALIDRAW:"转换空白笔记为 Excalidraw 绘图",CONVERT_EXCALIDRAW:"转换 *.excalidraw 为 *.md 文件",CREATE_NEW:"新建 Excalidraw 绘图",CONVERT_FILE_KEEP_EXT:"*.excalidraw => *.excalidraw.md",CONVERT_FILE_REPLACE_EXT:"*.excalidraw => *.md (兼容 Logseq)",DOWNLOAD_LIBRARY:"导出 stencil 库为 *.excalidrawlib 文件",OPEN_EXISTING_NEW_PANE:"打开已有的绘图（在新面板）",OPEN_EXISTING_ACTIVE_PANE:"打开已有的绘图（在当前面板）",TRANSCLUDE:"插入（嵌入）绘图到当前文档",TRANSCLUDE_MOST_RECENT:"插入（嵌入）最近编辑的绘图到当前文档",NEW_IN_NEW_PANE:"新建绘图（在新面板）",NEW_IN_ACTIVE_PANE:"新建绘图（在当前面板）",NEW_IN_NEW_PANE_EMBED:"新建绘图（在新面板），并插入（嵌入）到当前文档",NEW_IN_ACTIVE_PANE_EMBED:"新建绘图（在当前面板），并插入（嵌入）到当前文档",EXPORT_SVG:"导出 SVG 文件到当前目录",EXPORT_PNG:"导出 PNG 文件到当前目录",TOGGLE_LOCK:"切换文本元素的原文/预览模式",DELETE_FILE:"删除所选的图像或以图像形式嵌入的 Markdown 文档（包括其源文件）",INSERT_LINK_TO_ELEMENT:"复制所选元素（以链接形式）",INSERT_LINK_TO_ELEMENT_ERROR:"未选择画布里的单个元素",INSERT_LINK_TO_ELEMENT_READY:"链接已生成并复制到剪贴板",INSERT_LINK:"插入（链接）文件到当前绘图",INSERT_IMAGE:"插入（以图像形式嵌入）图像到当前绘图",INSERT_MD:"插入（以图像形式嵌入） Markdown 文档到当前绘图",INSERT_LATEX:"插入 LaTeX 公式",ENTER_LATEX:"输入 LaTeX 表达式",READ_RELEASE_NOTES:"阅读本插件的最新发行版本说明",TRAY_MODE:"切换绘图工具属性页的面板（Panel）/托盘（Tray）模式",SEARCH:"搜索文本",INSTALL_SCRIPT_BUTTON:"安装或更新 Excalidraw 自动化脚本",OPEN_AS_MD:"打开为 Markdown 文件（Markdown 模式）",SAVE_AS_PNG:"导出 PNG 到当前目录（按住 CTRL/CMD 设定导出路径）",SAVE_AS_SVG:"导出 SVG 到当前目录（按住 CTRL/CMD 设定导出路径）",OPEN_LINK:"打开所选元素里的链接 \n（按住 SHIFT 在新面板打开）",EXPORT_EXCALIDRAW:"导出为 .Excalidraw 文件",LINK_BUTTON_CLICK_NO_TEXT:"请选择一个含有链接的图形或文本元素。\n按住 SHIFT 并点击此按钮可在新面板中打开链接。\n您也可以直接在画布中按住 CTRL/CMD 并点击图形或文本元素来打开链接。",TEXT_ELEMENT_EMPTY:"未选中图形或文本元素，或者元素不包含有效的链接（[[链接|别名]] 或 [别名](链接)）",FILENAME_INVALID_CHARS:'文件名不能含有以下符号： * " \\ < > : | ? #',FILE_DOES_NOT_EXIST:"文件不存在。按住 ALT（或 ALT + SHIFT）并点击链接来创建新文件。",FORCE_SAVE:"立刻保存该绘图，并更新其他嵌入了该绘图的面板。\n（详见插件设置中的定期保存选项）",RAW:"文本元素正以原文（RAW）模式显示链接。\n点击切换到预览（PREVIEW）模式",PARSED:"文本元素正以预览（PREVIEW）模式显示链接。\n点击切换到原文（RAW）模式",NOFILE:"Excalidraw（没有文件）",COMPATIBILITY_MODE:"*.excalidraw 文件以兼容模式打开。转换为新格式以获得完整的插件功能。",CONVERT_FILE:"转换为新格式",RELEASE_NOTES_NAME:"显示更新说明",RELEASE_NOTES_DESC:"开启：每次更新本插件后，显示最新发行版本的说明。
关闭：您仍可以在 GitHub 上阅读更新说明。",FOLDER_NAME:"Excalidraw 文件夹",FOLDER_DESC:"新绘图的默认存储路径。若为空，将在库的根目录中创建新绘图。",FOLDER_EMBED_NAME:"将 Excalidraw 文件夹用于“新建绘图”命令创建的绘图",FOLDER_EMBED_DESC:"在命令面板中执行“新建绘图，并插入（嵌入）到当前文档”之类命令时，新绘图的存储路径。
开启：使用 Excalidraw 文件夹。 关闭：使用 Obsidian 设置的新附件默认位置。",TEMPLATE_NAME:"Excalidraw 模板文件",TEMPLATE_DESC:"Excalidraw 模板文件的完整路径。
如果您的模板在默认的 Excalidraw 文件夹中且文件名是 Template.md，则此项应设为 Excalidraw/Template.md（也可省略 .md 扩展名，即 Excalidraw/Template）。
如果您在兼容模式下使用 Excalidraw，那么您的模板文件也必须是旧的 *.excalidraw 格式，例如 Excalidraw/Template.excalidraw。",SCRIPT_FOLDER_NAME:"Excalidraw 自动化脚本的文件夹",SCRIPT_FOLDER_DESC:"此文件夹用于存放 Excalidraw 自动化脚本。您可以在 Obsidian 命令面板中执行这些脚本，还可以为喜欢的脚本分配快捷键，就像为其他 Obsidian 命令分配快捷键一样。
该项不能设为库的根目录。",COMPRESS_NAME:"压缩 Excalidraw JSON",COMPRESS_DESC:"Excalidraw 绘图文件默认将元素记录为 JSON 格式。开启此项，可将元素的 JSON 数据以 BASE64 编码（使用 LZ-String 算法）。这样做的好处是：一方面可以避免原来的明文 JSON 数据干扰 Obsidian 的文本搜索结果，另一方面减小了绘图文件的体积。
当您通过功能区按钮或命令将绘图切换成 Markdown 模式时，数据将被解码回 JSON 格式以便阅读和编辑；而当您切换回 Excalidraw 模式时，数据就会被再次编码。
开启此项后，对于之前已存在的未压缩的绘图文件，需要重新打开并保存它们才能生效。",AUTOSAVE_NAME:"定期保存",AUTOSAVE_DESC:"定期保存当前绘图。此功能专为移动设备设计 —— 在桌面端，当您关闭 Excalidraw 或 Obsidian，或者移动焦点到其他面板的时候，软件是会自动保存的；但是在手机或平板上通过滑动手势退出 Obsidian 时，可能无法顺利触发自动保存。因此我添加了定期保存功能作为弥补。",AUTOSAVE_INTERVAL_NAME:"定期保存的时间间隔",AUTOSAVE_INTERVAL_DESC:"每隔多长时间执行一次保存。如果当前绘图没有发生改变，将不会进行定期保存。",FILENAME_HEAD:"文件名",FILENAME_DESC:"

点击阅读日期和时间格式参考。

",FILENAME_SAMPLE:"当前设置下，新绘图的文件名形如：",FILENAME_EMBED_SAMPLE:"“新建绘图”命令创建的绘图的文件名形如：",FILENAME_PREFIX_NAME:"文件名前缀",FILENAME_PREFIX_DESC:"文件名的第一部分",FILENAME_PREFIX_EMBED_NAME:"“新建绘图”命令创建的绘图的文件名前缀",FILENAME_PREFIX_EMBED_DESC:"若开启此项，则在命令面板中执行“新建绘图，并插入（嵌入）到当前文档”之类命令时，创建的绘图文件名将以当前文档名作为开头。",FILENAME_POSTFIX_NAME:"“新建绘图”命令创建的绘图的文件名后缀",FILENAME_POSTFIX_DESC:"介于文件名前缀和文件名日期之间的文本。仅对“新建绘图”命令创建的绘图生效。",FILENAME_DATE_NAME:"文件名日期",FILENAME_DATE_DESC:"文件名的最后一部分",FILENAME_EXCALIDRAW_EXTENSION_NAME:"文件扩展名（.excalidraw.md 或 .md）",FILENAME_EXCALIDRAW_EXTENSION_DESC:"该选项在兼容模式（即非 Excalidraw 专用 Markdown 文件）下不会生效。
开启：使用 .excalidraw.md 作为扩展名；关闭：使用 .md 作为扩展名。",DISPLAY_HEAD:"显示",LEFTHANDED_MODE_NAME:"左手模式",LEFTHANDED_MODE_DESC:"目前只影响托盘模式下，绘图工具属性页的位置。若开启此项，则托盘处于右侧。",MATCH_THEME_NAME:"使新建的绘图匹配 Obsidian 主题",MATCH_THEME_DESC:"如果 Obsidian 使用黑暗主题，新建的绘图文件也将使用黑暗主题。
但是若设置了模板，新建的绘图文件将跟随模板主题；另外，此功能不会作用于已有的绘图。",MATCH_THEME_ALWAYS_NAME:"使已有的绘图匹配 Obsidian 主题",MATCH_THEME_ALWAYS_DESC:"如果 Obsidian 使用黑暗主题，则绘图文件也将以黑暗主题打开；反之亦然。",MATCH_THEME_TRIGGER_NAME:"Excalidraw 主题跟随 Obsidian 主题变化",MATCH_THEME_TRIGGER_DESC:"开启此项，则切换 Obsidian 的黑暗/明亮主题时，当前活动的 Excalidraw 面板的主题会随之改变。",DEFAULT_OPEN_MODE_NAME:"Excalidraw 的默认运行模式",DEFAULT_OPEN_MODE_DESC:"设置 Excalidraw 的运行模式：普通模式，禅模式，或者阅读模式。
您可为某个绘图单独设置此项，方法是在其 Frontmatter 中添加形如 excalidraw-default-mode: normal/zen/view 的键值对。",ZOOM_TO_FIT_NAME:"自动缩放以适应面板调整",ZOOM_TO_FIT_DESC:"调整面板大小时，自适应地缩放画布",ZOOM_TO_FIT_MAX_LEVEL_NAME:"自动缩放的最高级别",ZOOM_TO_FIT_MAX_LEVEL_DESC:"自动缩放画布时，允许放大的最高级别。该值不能低于 0.5（50%）且不能超过 10（1000%）。",LINKS_HEAD:"链接（Links） & 嵌入到绘图中的文档（Transclusion）",LINKS_DESC:"按住 CTRL/CMD 并点击包含 [[链接]] 的文本元素可以打开其中的链接。如果所选文本元素包含多个 [[有效的 Obsidian 链接]] ，只会打开第一个链接；如果所选文本元素包含有效的 URL 链接 (如 https:// 或 http://)，插件会在浏览器中打开 URL 链接。
链接的源文件被重命名时，绘图中相应的 [[链接]] 也会同步更新。若您不愿绘图中的链接文本因此而变化，可用 [[链接|别名]] 来使用别名。",ADJACENT_PANE_NAME:"在相邻面板中打开",ADJACENT_PANE_DESC:"按住 CTRL/CMD + SHIFT 并点击链接时，插件默认会在新面板中打开该链接。
若开启此项，Excalidraw 会先尝试寻找已有的相邻面板（按照右侧、左侧、上方、下方的顺序），并在其中打开链接。如果找不到，再在新面板中打开链接。",LINK_BRACKETS_NAME:"在链接的两侧显示 [[中括号]]",LINK_BRACKETS_DESC:"文本元素处于预览模式时，在链接的两侧显示中括号。
您可为某个绘图单独设置此项，方法是在其 Frontmatter 中添加形如 excalidraw-link-brackets: true/false 的键值对。",LINK_PREFIX_NAME:"链接的前缀",LINK_PREFIX_DESC:'文本元素处于预览模式时，如果其中包含链接，则添加此前缀。
您可为某个绘图单独设置此项，方法是在其 Frontmatter 中添加形如 excalidraw-link-prefix: "📍 " 的键值对。',URL_PREFIX_NAME:"URL 的前缀",URL_PREFIX_DESC:'预览模式下，如果文本元素包含 URL 链接，则添加此前缀。
您可为某个绘图单独设置此项，方法是在其 Frontmatter 中添加形如 excalidraw-url-prefix: "🌐 " 的键值对。',HOVERPREVIEW_NAME:"鼠标悬停预览链接",HOVERPREVIEW_DESC:"开启：鼠标悬停在 [[链接]] 上即可预览。
关闭：鼠标悬停在 [[链接]] 上，并且按住 CTRL/CMD 时进行预览。",LINKOPACITY_NAME:"链接标识的透明度",LINKOPACITY_DESC:"含有链接的元素，其右上角的链接标识的透明度。介于 0（全透明）到 1（不透明）之间。",LINK_CTRL_CLICK_NAME:"按住 CTRL/CMD 并点击含有 [[链接]] 或 [别名](链接) 的文本来打开链接",LINK_CTRL_CLICK_DESC:"如果此功能影响到您使用某些原版 Excalidraw 功能，可将其关闭。关闭后，您只能通过绘图面板标题栏中的链接按钮来打开链接。",TRANSCLUSION_WRAP_NAME:"嵌入文档（Translusion）的折行方式",TRANSCLUSION_WRAP_DESC:"中的 number 表示嵌入的文本溢出时，在第几个字符处进行折行。
此开关控制具体的折行方式。若开启，则严格在 number 处折行，禁止溢出；若关闭，则允许在 number 位置后最近的空格处折行。",TRANSCLUSION_DEFAULT_WRAP_NAME:"嵌入文档（Translusion）的默认折行位置",TRANSCLUSION_DEFAULT_WRAP_DESC:"除了通过 ![[doc#^block]]{number} 中的 number 来控制折行位置，您也可以在此设置 number 的默认值。
一般设为 0 即可，表示不设置固定的默认值，这样当您需要嵌入文档到便签中时，Excalidraw 能更好地帮您自动处理。",PAGE_TRANSCLUSION_CHARCOUNT_NAME:"嵌入文档（Translusion）的最大显示字符数",PAGE_TRANSCLUSION_CHARCOUNT_DESC:"以 ![[Markdown 文档]] 的形式将文档嵌入到绘图中时，该文档在绘图中可显示的最大字符数量。",GET_URL_TITLE_NAME:"使用 iframly 获取页面标题",GET_URL_TITLE_DESC:"拖放链接到 Excalidraw 时，使用 http://iframely.server.crestify.com/iframely?url= 来获取页面的标题。",MD_HEAD:"以图像形式嵌入到绘图中的 Markdown 文档（MD-Embed）",MD_HEAD_DESC:"您可以将 Markdown 文档以图像（而非链接）的形式嵌入到绘图中，方法是按住 CTRL/CMD 并从文件管理器中把文档拖入绘图，或者使用命令面板里的相关命令。",MD_TRANSCLUDE_WIDTH_NAME:"MD-Embed 的默认宽度",MD_TRANSCLUDE_WIDTH_DESC:"MD-Embed 图像的宽度。该选项会影响到折行，以及图像元素的宽度。
您可为绘图中的某个 MD-Embed 单独设置此项，方法是将绘图切换至 Markdown 模式，并修改相应的 [[Embed文件名#标题|宽度x最大高度]]。",MD_TRANSCLUDE_HEIGHT_NAME:"MD-Embed 的默认最大高度",MD_TRANSCLUDE_HEIGHT_DESC:"MD-Embed 图像的高度取决于文档内容的多少，但最大不会超过该值。
您可为绘图中的某个 MD-Embed 单独设置此项，方法是将绘图切换至 Markdown 模式，并修改相应的 [[Embed文件名#^块引ID|宽度x最大高度]]。",MD_DEFAULT_FONT_NAME:"MD-Embed 的默认字体",MD_DEFAULT_FONT_DESC:"可以设为 Virgil，Casadia 或其他有效的 .ttf/.woff/.woff2 字体文件（如 我的字体.woff2）。
您可为某个 MD-Embed 单独设置此项，方法是在其源文件的 Frontmatter 中添加形如 excalidraw-font: 字体名或文件名 的键值对。",MD_DEFAULT_COLOR_NAME:"MD-Embed 的默认文本颜色",MD_DEFAULT_COLOR_DESC:"可以填写 HTML 颜色名，如 steelblue（参考 HTML Color Names），或者有效的 16 进制颜色值，例如 #e67700，或者任何其他有效的 CSS 颜色。
您可为某个 MD-Embed 单独设置此项，方法是在其源文件的 Frontmatter 中添加形如 excalidraw-font-color: steelblue 的键值对。",MD_DEFAULT_BORDER_COLOR_NAME:"MD-Embed 的默认边框颜色",MD_DEFAULT_BORDER_COLOR_DESC:"可以填写 HTML 颜色名，如 steelblue（参考 HTML Color Names），或者有效的 16 进制颜色值，例如 #e67700，或者任何其他有效的 CSS 颜色。
您可为某个 MD-Embed 单独设置此项，方法是在其源文件的 Frontmatter 中添加形如 excalidraw-border-color: gray 的键值对。
如果您不想要边框，请留空。",MD_CSS_NAME:"MD-Embed 的默认 CSS 样式表",MD_CSS_DESC:"MD-Embed 图像所采用的 CSS 样式表文件名。需包含扩展名，例如 md-embed.css。允许使用 Markdown 文件（如 md-embed-css.md），但其内容应符合 CSS 语法。
如果您要查询 CSS 所作用的 HTML 节点，请在 Obsidian 开发者控制台（CTRL+SHIFT+i）中键入命令：ExcalidrawAutomate.mostRecentMarkdownSVG —— 这将显示 Excalidraw 最近生成的 SVG。
此外，在 CSS 中不能任意地设置字体，您一般只能使用系统默认的标准字体（详见 README），但可以通过上面的设置来额外添加一个自定义字体。
您可为某个 MD-Embed 单独设置此项，方法是在其源文件的 Frontmatter 中添加形如 excalidraw-css: 库中的CSS文件或CSS片段 的键值对。",EMBED_HEAD:"嵌入到文档中的绘图（Embed） & 导出",EMBED_PREVIEW_SVG_NAME:"在 Markdown 阅读视图下显示 SVG 格式的预览图",EMBED_PREVIEW_SVG_DESC:"Obsidian 的 Markdown 阅读视图默认会将嵌入的绘图显示为 SVG 格式的预览图。若关闭此项，则显示为 PNG 格式。",PREVIEW_MATCH_OBSIDIAN_NAME:"预览图匹配 Obsidian 主题",PREVIEW_MATCH_OBSIDIAN_DESC:"开启此项，则当 Obsidian 处于黑暗模式时，预览图也会以黑暗模式渲染；当 Obsidian 处于明亮模式时，的预览图也会以明亮模式渲染。
您可能还需要关闭“导出的图像包含背景”开关，来获得与 Obsidian 更加协调的观感。",EMBED_WIDTH_NAME:"预览图的默认宽度",EMBED_WIDTH_DESC:"该选项同时作用于 Obsidian 实时预览模式下的编辑视图和阅读视图，以及鼠标悬停时的预览图。
您可为嵌入到文档中的某个绘图单独设置此项，方法是修改相应的链接格式为形如 ![[drawing.excalidraw|100]] 或 [[drawing.excalidraw|100x100]] 的格式。",EMBED_TYPE_NAME:"“嵌入绘图到当前文档”命令的源文件类型",EMBED_TYPE_DESC:"在命令面板中执行“嵌入绘图到当前文档”之类命令时，要嵌入绘图文件，还是嵌入其 PNG 或 SVG 副本。
如果您想在该下拉框中选择 PNG 或 SVG 副本，需要先开启下方的“自动导出 PNG 格式副本”或“自动导出 SVG 格式副本”开关。若您选择了嵌入 PNG 或 SVG 副本，当绘图缺少对应的 PNG 或 SVG 副本时，该命令将会插入一条损坏的链接，您需要打开绘图文件并手动导出副本才能修复 —— 该选项不会帮您自动生成 PNG/SVG 副本，而只会引用已经存在的 PNG/SVG 副本。",EMBED_WIKILINK_NAME:"“嵌入绘图到当前文档”命令产生的链接类型",EMBED_WIKILINK_DESC:"开启：将产生 ![[Wiki 链接]]。关闭：将产生 ![](Markdown 链接)。",EXPORT_PNG_SCALE_NAME:"导出 PNG 图像的比例",EXPORT_PNG_SCALE_DESC:"导出的 PNG 图像的大小比例",EXPORT_BACKGROUND_NAME:"导出的图像包含背景",EXPORT_BACKGROUND_DESC:"如果关闭，将导出透明背景的图像。",EXPORT_SVG_PADDING_NAME:"导出 SVG 图像的边距",EXPORT_SVG_PADDING_DESC:"导出的 PNG 图像的空白边距（像素）。增加该值，可以避免在导出 SVG 图像时，过于靠近画布边缘的图形被裁掉。",EXPORT_THEME_NAME:"导出的图像包含主题",EXPORT_THEME_DESC:"导出与绘图的黑暗/明亮主题匹配的图像。如果关闭，在黑暗主题下导出的图像将和明亮主题一样。",EXPORT_HEAD:"导出设置",EXPORT_SYNC_NAME:"保持 .SVG 和 .PNG 文件名与绘图文件同步",EXPORT_SYNC_DESC:"打开后，当绘图文件被重命名时，插件将同步更新同文件夹下的同名 .SVG 和 .PNG 文件。当绘图文件被删除时，插件将自动删除同文件夹下的同名 .SVG 和 .PNG 文件。",EXPORT_SVG_NAME:"自动导出 SVG 格式副本",EXPORT_SVG_DESC:"自动导出和绘图文件同名的 SVG 格式副本。插件会将副本保存到绘图文件所在的文件夹中。在文档中嵌入这个 SVG 文件，相比直接嵌入绘图文件，具有更强的跨平台能力。
此开关开启时，每次您编辑 Excalidraw 绘图，其 SVG 文件副本都会同步更新。",EXPORT_PNG_NAME:"自动导出 PNG 格式副本",EXPORT_PNG_DESC:"和“自动导出 SVG 格式副本”类似，但是导出格式为 *.PNG。",COMPATIBILITY_HEAD:"兼容性设置",EXPORT_EXCALIDRAW_NAME:"自动导出 Excalidraw 格式副本",EXPORT_EXCALIDRAW_DESC:"和“自动导出 SVG 格式副本”类似，但是导出格式为 *.excalidraw。",SYNC_EXCALIDRAW_NAME:"保持同一绘图的新旧格式文件内容一致",SYNC_EXCALIDRAW_DESC:"如果旧格式（*.excalidraw）绘图文件的修改日期比新格式（*.md）更新，则根据旧格式文件的内容来更新新格式文件。",COMPATIBILITY_MODE_NAME:"以旧格式创建新绘图",COMPATIBILITY_MODE_DESC:"开启此功能后，您通过功能区按钮、命令面板、文件浏览器等创建的绘图都将是旧格式（*.excalidraw）。此外，您打开旧格式绘图文件时将不再收到提醒消息。",EXPERIMENTAL_HEAD:"实验性功能",EXPERIMENTAL_DESC:"以下部分设置不会立即生效，需要刷新文件资源管理器或者重启 Obsidian 才会生效。",FIELD_SUGGESTER_NAME:"开启 Field Suggester",FIELD_SUGGESTER_DESC:"开启后，当您在编辑器中输入 excalidraw- 或者 ea. 时，会弹出一个带有函数说明的自动补全提示菜单。
该功能借鉴了 Breadcrumbs 和 Templater 插件。",FILETYPE_NAME:"在文件浏览器中为 excalidraw.md 文件添加类型标识符（如 ✏️）",FILETYPE_DESC:"可通过下一项设置来自定义类型标识符。",FILETAG_NAME:"excalidraw.md 文件的类型标识符",FILETAG_DESC:"要显示为类型标识符的 emoji 或文本。",INSERT_EMOJI:"插入 emoji",LIVEPREVIEW_NAME:"嵌入绘图到文档时，模拟嵌入图像的语法",LIVEPREVIEW_DESC:"开启此项，则可在 Obsidian 实时预览模式的编辑视图下，用形如 ![[绘图|宽度|样式]] 的语法来嵌入绘图。
该选项不会在已打开的文档中立刻生效 —— 你需要重新打开此文档来使其生效。",ENABLE_FOURTH_FONT_NAME:"为文本元素启用本地字体",ENABLE_FOURTH_FONT_DESC:"开启此项后，文本元素的属性面板里会多出一个本地字体按钮。
使用了本地字体的绘图文件，将会失去一部分跨平台能力 —— 若将绘图文件移动到其他库中打开，显示效果可能会截然不同；若在 excalidraw.com 或者其他版本的 Excalidraw 中打开，使用本地字体的文本会变回系统默认字体。",FOURTH_FONT_NAME:"本地字体文件",FOURTH_FONT_DESC:"选择库文件夹中的一个 .ttf, .woff 或 .woff2 字体文件作为本地字体文件。若未选择文件，则使用默认的 Virgil 字体。",SCRIPT_SETTINGS_HEAD:"已安装脚本的设置",SELECT_FILE:"选择一个文件后按回车。",NO_MATCH:"查询不到匹配的文件。",SELECT_FILE_TO_LINK:"选择要插入（链接）到当前绘图中的文件。",SELECT_DRAWING:"选择要插入（以图像形式嵌入）到当前绘图中的图像。",TYPE_FILENAME:"键入要选择的绘图名称。",SELECT_FILE_OR_TYPE_NEW:"选择已有绘图，或者新绘图的类型，然后按回车。",SELECT_TO_EMBED:"选择要插入（嵌入）到当前文档中的绘图。",SELECT_MD:"选择要插入（以图像形式嵌入）到当前绘图中的 Markdown 文档。",INFINITE_LOOP_WARNING:"EXCALIDRAW 警告\n停止加载嵌入的图像，因为此文件中存在死循环：\n",SCRIPT_EXECUTION_ERROR:"脚本运行错误。请在开发者控制台中查看错误信息。",LOAD_FROM_BACKUP:"Excalidraw 文件已损坏。尝试从备份文件中加载。",GOTO_FULLSCREEN:"进入全屏模式",EXIT_FULLSCREEN:"退出全屏模式",TOGGLE_FULLSCREEN:"切换全屏模式"},zhTW={};const localeMap={ar:ar,cs:cz,da:da,de:de,en:en,"en-gb":enGB,es:es,fr:fr,hi:hi,id:id,it:it,ja:ja,ko:ko,nl:nl,nn:no,pl:pl,pt:pt,"pt-br":ptBR,ro:ro,ru:ru,tr:tr,"zh-cn":zhCN,"zh-tw":zhTW},locale=localeMap[obsidian.moment.locale()];function t(A){return locale||errorlog({where:"helpers.t",message:"Error: Excalidraw locale not found",locale:obsidian.moment.locale()}),locale&&locale[A]||en[A]}var html2canvas$1={exports:{}}; +/*! + * html2canvas 1.4.0 + * Copyright (c) 2022 Niklas von Hertzen + * Released under MIT License + */html2canvas$1.exports=function(){ +/*! ***************************************************************************** + Copyright (c) Microsoft Corporation. + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted. + + THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH + REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, + INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM + LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR + OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + PERFORMANCE OF THIS SOFTWARE. + ***************************************************************************** */ +var A=function(e,t){return A=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(A,e){A.__proto__=e}||function(A,e){for(var t in e)Object.prototype.hasOwnProperty.call(e,t)&&(A[t]=e[t])},A(e,t)};function e(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Class extends value "+String(t)+" is not a constructor or null");function i(){this.constructor=e}A(e,t),e.prototype=null===t?Object.create(t):(i.prototype=t.prototype,new i)}var t=function(){return t=Object.assign||function(A){for(var e,t=1,i=arguments.length;t0&&n[n.length-1])||6!==a[0]&&2!==a[0])){s=0;continue}if(3===a[0]&&(!n||a[1]>n[0]&&a[1]=55296&&n<=56319&&t>10),s%1024+56320)),(n+1===t||i.length>16384)&&(a+=String.fromCharCode.apply(String,i),i.length=0)}return a},c="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",d="undefined"==typeof Uint8Array?[]:new Uint8Array(256),h=0;h=0){if(A<55296||A>56319&&A<=65535)return e=((e=this.index[A>>5])<<2)+(31&A),this.data[e];if(A<=65535)return e=((e=this.index[2048+(A-55296>>5)])<<2)+(31&A),this.data[e];if(A>11),e=this.index[e],e+=A>>5&63,e=((e=this.index[e])<<2)+(31&A),this.data[e];if(A<=1114111)return this.data[this.highValueIndex]}return this.errorValue},A}(),w=10,p=13,B=15,m=17,f=18,E=19,C=20,F=21,v=22,y=24,Q=25,b=26,U=27,x=28,I=30,S=32,T=33,L=34,M=35,H=37,D=38,k=39,N=40,O=42,R=[9001,65288],P="×",V="÷",K=function(A){var e,t,i,n=function(A){var e,t,i,n,a,s=.75*A.length,r=A.length,o=0;"="===A[A.length-1]&&(s--,"="===A[A.length-2]&&s--);var l="undefined"!=typeof ArrayBuffer&&"undefined"!=typeof Uint8Array&&void 0!==Uint8Array.prototype.slice?new ArrayBuffer(s):new Array(s),c=Array.isArray(l)?l:new Uint8Array(l);for(e=0;e>4,c[o++]=(15&i)<<4|n>>2,c[o++]=(3&n)<<6|63&a;return l}(A),a=Array.isArray(n)?function(A){for(var e=A.length,t=[],i=0;i0;){var s=i[--a];if(Array.isArray(A)?-1!==A.indexOf(s):A===s)for(var r=t;r<=i.length;){var o;if((o=i[++r])===e)return!0;if(o!==w)break}if(s!==w)break}return!1},q=function(A,e){for(var t=A;t>=0;){var i=e[t];if(i!==w)return i;t--}return 0},_=function(A,e,t,i,n){if(0===t[i])return P;var a=i-1;if(Array.isArray(n)&&!0===n[a])return P;var s=a-1,r=a+1,o=e[a],l=s>=0?e[s]:0,c=e[r];if(2===o&&3===c)return P;if(-1!==W.indexOf(o))return"!";if(-1!==W.indexOf(c))return P;if(-1!==X.indexOf(c))return P;if(8===q(a,e))return V;if(11===K.get(A[a]))return P;if((o===S||o===T)&&11===K.get(A[r]))return P;if(7===o||7===c)return P;if(9===o)return P;if(-1===[w,p,B].indexOf(o)&&9===c)return P;if(-1!==[m,f,E,y,x].indexOf(c))return P;if(q(a,e)===v)return P;if(Z(23,v,a,e))return P;if(Z([m,f],F,a,e))return P;if(Z(12,12,a,e))return P;if(o===w)return V;if(23===o||23===c)return P;if(16===c||16===o)return V;if(-1!==[p,B,F].indexOf(c)||14===o)return P;if(36===l&&-1!==j.indexOf(o))return P;if(o===x&&36===c)return P;if(c===C)return P;if(-1!==G.indexOf(c)&&o===Q||-1!==G.indexOf(o)&&c===Q)return P;if(o===U&&-1!==[H,S,T].indexOf(c)||-1!==[H,S,T].indexOf(o)&&c===b)return P;if(-1!==G.indexOf(o)&&-1!==z.indexOf(c)||-1!==z.indexOf(o)&&-1!==G.indexOf(c))return P;if(-1!==[U,b].indexOf(o)&&(c===Q||-1!==[v,B].indexOf(c)&&e[r+1]===Q)||-1!==[v,B].indexOf(o)&&c===Q||o===Q&&-1!==[Q,x,y].indexOf(c))return P;if(-1!==[Q,x,y,m,f].indexOf(c))for(var d=a;d>=0;){if((h=e[d])===Q)return P;if(-1===[x,y].indexOf(h))break;d--}if(-1!==[U,b].indexOf(c))for(d=-1!==[m,f].indexOf(o)?s:a;d>=0;){var h;if((h=e[d])===Q)return P;if(-1===[x,y].indexOf(h))break;d--}if(D===o&&-1!==[D,k,L,M].indexOf(c)||-1!==[k,L].indexOf(o)&&-1!==[k,N].indexOf(c)||-1!==[N,M].indexOf(o)&&c===N)return P;if(-1!==J.indexOf(o)&&-1!==[C,b].indexOf(c)||-1!==J.indexOf(c)&&o===U)return P;if(-1!==G.indexOf(o)&&-1!==G.indexOf(c))return P;if(o===y&&-1!==G.indexOf(c))return P;if(-1!==G.concat(Q).indexOf(o)&&c===v&&-1===R.indexOf(A[r])||-1!==G.concat(Q).indexOf(c)&&o===f)return P;if(41===o&&41===c){for(var g=t[a],u=1;g>0&&41===e[--g];)u++;if(u%2!=0)return P}return o===S&&c===T?P:V},$=function(A,e){e||(e={lineBreak:"normal",wordBreak:"normal"});var t=function(A,e){void 0===e&&(e="strict");var t=[],i=[],n=[];return A.forEach((function(A,a){var s=K.get(A);if(s>50?(n.push(!0),s-=50):n.push(!1),-1!==["normal","auto","loose"].indexOf(e)&&-1!==[8208,8211,12316,12448].indexOf(A))return i.push(a),t.push(16);if(4===s||11===s){if(0===a)return i.push(a),t.push(I);var r=t[a-1];return-1===Y.indexOf(r)?(i.push(i[a-1]),t.push(r)):(i.push(a),t.push(I))}return i.push(a),31===s?t.push("strict"===e?F:H):s===O||29===s?t.push(I):43===s?A>=131072&&A<=196605||A>=196608&&A<=262141?t.push(H):t.push(I):void t.push(s)})),[i,t,n]}(A,e.lineBreak),i=t[0],n=t[1],a=t[2];"break-all"!==e.wordBreak&&"break-word"!==e.wordBreak||(n=n.map((function(A){return-1!==[Q,I,O].indexOf(A)?H:A})));var s="keep-all"===e.wordBreak?a.map((function(e,t){return e&&A[t]>=19968&&A[t]<=40959})):void 0;return[i,n,s]},AA=function(){function A(A,e,t,i){this.codePoints=A,this.required="!"===e,this.start=t,this.end=i}return A.prototype.slice=function(){return l.apply(void 0,this.codePoints.slice(this.start,this.end))},A}(),eA=45,tA=43,iA=-1,nA=function(A){return A>=48&&A<=57},aA=function(A){return nA(A)||A>=65&&A<=70||A>=97&&A<=102},sA=function(A){return 10===A||9===A||32===A},rA=function(A){return function(A){return function(A){return A>=97&&A<=122}(A)||function(A){return A>=65&&A<=90}(A)}(A)||function(A){return A>=128}(A)||95===A},oA=function(A){return rA(A)||nA(A)||A===eA},lA=function(A){return A>=0&&A<=8||11===A||A>=14&&A<=31||127===A},cA=function(A,e){return 92===A&&10!==e},dA=function(A,e,t){return A===eA?rA(e)||cA(e,t):!!rA(A)||!(92!==A||!cA(A,e))},hA=function(A,e,t){return A===tA||A===eA?!!nA(e)||46===e&&nA(t):nA(46===A?e:A)},gA=function(A){var e=0,t=1;A[e]!==tA&&A[e]!==eA||(A[e]===eA&&(t=-1),e++);for(var i=[];nA(A[e]);)i.push(A[e++]);var n=i.length?parseInt(l.apply(void 0,i),10):0;46===A[e]&&e++;for(var a=[];nA(A[e]);)a.push(A[e++]);var s=a.length,r=s?parseInt(l.apply(void 0,a),10):0;69!==A[e]&&101!==A[e]||e++;var o=1;A[e]!==tA&&A[e]!==eA||(A[e]===eA&&(o=-1),e++);for(var c=[];nA(A[e]);)c.push(A[e++]);var d=c.length?parseInt(l.apply(void 0,c),10):0;return t*(n+r*Math.pow(10,-s))*Math.pow(10,o*d)},uA={type:2},wA={type:3},pA={type:4},BA={type:13},mA={type:8},fA={type:21},EA={type:9},CA={type:10},FA={type:11},vA={type:12},yA={type:14},QA={type:23},bA={type:1},UA={type:25},xA={type:24},IA={type:26},SA={type:27},TA={type:28},LA={type:29},MA={type:31},HA={type:32},DA=function(){function A(){this._value=[]}return A.prototype.write=function(A){this._value=this._value.concat(o(A))},A.prototype.read=function(){for(var A=[],e=this.consumeToken();e!==HA;)A.push(e),e=this.consumeToken();return A},A.prototype.consumeToken=function(){var A=this.consumeCodePoint();switch(A){case 34:return this.consumeStringToken(34);case 35:var e=this.peekCodePoint(0),t=this.peekCodePoint(1),i=this.peekCodePoint(2);if(oA(e)||cA(t,i)){var n=dA(e,t,i)?2:1;return{type:5,value:this.consumeName(),flags:n}}break;case 36:if(61===this.peekCodePoint(0))return this.consumeCodePoint(),BA;break;case 39:return this.consumeStringToken(39);case 40:return uA;case 41:return wA;case 42:if(61===this.peekCodePoint(0))return this.consumeCodePoint(),yA;break;case tA:if(hA(A,this.peekCodePoint(0),this.peekCodePoint(1)))return this.reconsumeCodePoint(A),this.consumeNumericToken();break;case 44:return pA;case eA:var a=A,s=this.peekCodePoint(0),r=this.peekCodePoint(1);if(hA(a,s,r))return this.reconsumeCodePoint(A),this.consumeNumericToken();if(dA(a,s,r))return this.reconsumeCodePoint(A),this.consumeIdentLikeToken();if(s===eA&&62===r)return this.consumeCodePoint(),this.consumeCodePoint(),xA;break;case 46:if(hA(A,this.peekCodePoint(0),this.peekCodePoint(1)))return this.reconsumeCodePoint(A),this.consumeNumericToken();break;case 47:if(42===this.peekCodePoint(0))for(this.consumeCodePoint();;){var o=this.consumeCodePoint();if(42===o&&47===(o=this.consumeCodePoint()))return this.consumeToken();if(o===iA)return this.consumeToken()}break;case 58:return IA;case 59:return SA;case 60:if(33===this.peekCodePoint(0)&&this.peekCodePoint(1)===eA&&this.peekCodePoint(2)===eA)return this.consumeCodePoint(),this.consumeCodePoint(),UA;break;case 64:var c=this.peekCodePoint(0),d=this.peekCodePoint(1),h=this.peekCodePoint(2);if(dA(c,d,h))return{type:7,value:this.consumeName()};break;case 91:return TA;case 92:if(cA(A,this.peekCodePoint(0)))return this.reconsumeCodePoint(A),this.consumeIdentLikeToken();break;case 93:return LA;case 61:if(61===this.peekCodePoint(0))return this.consumeCodePoint(),mA;break;case 123:return FA;case 125:return vA;case 117:case 85:var g=this.peekCodePoint(0),u=this.peekCodePoint(1);return g!==tA||!aA(u)&&63!==u||(this.consumeCodePoint(),this.consumeUnicodeRangeToken()),this.reconsumeCodePoint(A),this.consumeIdentLikeToken();case 124:if(61===this.peekCodePoint(0))return this.consumeCodePoint(),EA;if(124===this.peekCodePoint(0))return this.consumeCodePoint(),fA;break;case 126:if(61===this.peekCodePoint(0))return this.consumeCodePoint(),CA;break;case iA:return HA}return sA(A)?(this.consumeWhiteSpace(),MA):nA(A)?(this.reconsumeCodePoint(A),this.consumeNumericToken()):rA(A)?(this.reconsumeCodePoint(A),this.consumeIdentLikeToken()):{type:6,value:l(A)}},A.prototype.consumeCodePoint=function(){var A=this._value.shift();return void 0===A?-1:A},A.prototype.reconsumeCodePoint=function(A){this._value.unshift(A)},A.prototype.peekCodePoint=function(A){return A>=this._value.length?-1:this._value[A]},A.prototype.consumeUnicodeRangeToken=function(){for(var A=[],e=this.consumeCodePoint();aA(e)&&A.length<6;)A.push(e),e=this.consumeCodePoint();for(var t=!1;63===e&&A.length<6;)A.push(e),e=this.consumeCodePoint(),t=!0;if(t)return{type:30,start:parseInt(l.apply(void 0,A.map((function(A){return 63===A?48:A}))),16),end:parseInt(l.apply(void 0,A.map((function(A){return 63===A?70:A}))),16)};var i=parseInt(l.apply(void 0,A),16);if(this.peekCodePoint(0)===eA&&aA(this.peekCodePoint(1))){this.consumeCodePoint(),e=this.consumeCodePoint();for(var n=[];aA(e)&&n.length<6;)n.push(e),e=this.consumeCodePoint();return{type:30,start:i,end:parseInt(l.apply(void 0,n),16)}}return{type:30,start:i,end:i}},A.prototype.consumeIdentLikeToken=function(){var A=this.consumeName();return"url"===A.toLowerCase()&&40===this.peekCodePoint(0)?(this.consumeCodePoint(),this.consumeUrlToken()):40===this.peekCodePoint(0)?(this.consumeCodePoint(),{type:19,value:A}):{type:20,value:A}},A.prototype.consumeUrlToken=function(){var A=[];if(this.consumeWhiteSpace(),this.peekCodePoint(0)===iA)return{type:22,value:""};var e=this.peekCodePoint(0);if(39===e||34===e){var t=this.consumeStringToken(this.consumeCodePoint());return 0===t.type&&(this.consumeWhiteSpace(),this.peekCodePoint(0)===iA||41===this.peekCodePoint(0))?(this.consumeCodePoint(),{type:22,value:t.value}):(this.consumeBadUrlRemnants(),QA)}for(;;){var i=this.consumeCodePoint();if(i===iA||41===i)return{type:22,value:l.apply(void 0,A)};if(sA(i))return this.consumeWhiteSpace(),this.peekCodePoint(0)===iA||41===this.peekCodePoint(0)?(this.consumeCodePoint(),{type:22,value:l.apply(void 0,A)}):(this.consumeBadUrlRemnants(),QA);if(34===i||39===i||40===i||lA(i))return this.consumeBadUrlRemnants(),QA;if(92===i){if(!cA(i,this.peekCodePoint(0)))return this.consumeBadUrlRemnants(),QA;A.push(this.consumeEscapedCodePoint())}else A.push(i)}},A.prototype.consumeWhiteSpace=function(){for(;sA(this.peekCodePoint(0));)this.consumeCodePoint()},A.prototype.consumeBadUrlRemnants=function(){for(;;){var A=this.consumeCodePoint();if(41===A||A===iA)return;cA(A,this.peekCodePoint(0))&&this.consumeEscapedCodePoint()}},A.prototype.consumeStringSlice=function(A){for(var e="";A>0;){var t=Math.min(5e4,A);e+=l.apply(void 0,this._value.splice(0,t)),A-=t}return this._value.shift(),e},A.prototype.consumeStringToken=function(A){for(var e="",t=0;;){var i=this._value[t];if(i===iA||void 0===i||i===A)return{type:0,value:e+=this.consumeStringSlice(t)};if(10===i)return this._value.splice(0,t),bA;if(92===i){var n=this._value[t+1];n!==iA&&void 0!==n&&(10===n?(e+=this.consumeStringSlice(t),t=-1,this._value.shift()):cA(i,n)&&(e+=this.consumeStringSlice(t),e+=l(this.consumeEscapedCodePoint()),t=-1))}t++}},A.prototype.consumeNumber=function(){var A=[],e=4,t=this.peekCodePoint(0);for(t!==tA&&t!==eA||A.push(this.consumeCodePoint());nA(this.peekCodePoint(0));)A.push(this.consumeCodePoint());t=this.peekCodePoint(0);var i=this.peekCodePoint(1);if(46===t&&nA(i))for(A.push(this.consumeCodePoint(),this.consumeCodePoint()),e=8;nA(this.peekCodePoint(0));)A.push(this.consumeCodePoint());t=this.peekCodePoint(0),i=this.peekCodePoint(1);var n=this.peekCodePoint(2);if((69===t||101===t)&&((i===tA||i===eA)&&nA(n)||nA(i)))for(A.push(this.consumeCodePoint(),this.consumeCodePoint()),e=8;nA(this.peekCodePoint(0));)A.push(this.consumeCodePoint());return[gA(A),e]},A.prototype.consumeNumericToken=function(){var A=this.consumeNumber(),e=A[0],t=A[1],i=this.peekCodePoint(0),n=this.peekCodePoint(1),a=this.peekCodePoint(2);return dA(i,n,a)?{type:15,number:e,flags:t,unit:this.consumeName()}:37===i?(this.consumeCodePoint(),{type:16,number:e,flags:t}):{type:17,number:e,flags:t}},A.prototype.consumeEscapedCodePoint=function(){var A=this.consumeCodePoint();if(aA(A)){for(var e=l(A);aA(this.peekCodePoint(0))&&e.length<6;)e+=l(this.consumeCodePoint());sA(this.peekCodePoint(0))&&this.consumeCodePoint();var t=parseInt(e,16);return 0===t||function(A){return A>=55296&&A<=57343}(t)||t>1114111?65533:t}return A===iA?65533:A},A.prototype.consumeName=function(){for(var A="";;){var e=this.consumeCodePoint();if(oA(e))A+=l(e);else{if(!cA(e,this.peekCodePoint(0)))return this.reconsumeCodePoint(e),A;A+=l(this.consumeEscapedCodePoint())}}},A}(),kA=function(){function A(A){this._tokens=A}return A.create=function(e){var t=new DA;return t.write(e),new A(t.read())},A.parseValue=function(e){return A.create(e).parseComponentValue()},A.parseValues=function(e){return A.create(e).parseComponentValues()},A.prototype.parseComponentValue=function(){for(var A=this.consumeToken();31===A.type;)A=this.consumeToken();if(32===A.type)throw new SyntaxError("Error parsing CSS component value, unexpected EOF");this.reconsumeToken(A);var e=this.consumeComponentValue();do{A=this.consumeToken()}while(31===A.type);if(32===A.type)return e;throw new SyntaxError("Error parsing CSS component value, multiple values found when expecting only one")},A.prototype.parseComponentValues=function(){for(var A=[];;){var e=this.consumeComponentValue();if(32===e.type)return A;A.push(e),A.push()}},A.prototype.consumeComponentValue=function(){var A=this.consumeToken();switch(A.type){case 11:case 28:case 2:return this.consumeSimpleBlock(A.type);case 19:return this.consumeFunction(A)}return A},A.prototype.consumeSimpleBlock=function(A){for(var e={type:A,values:[]},t=this.consumeToken();;){if(32===t.type||XA(t,A))return e;this.reconsumeToken(t),e.values.push(this.consumeComponentValue()),t=this.consumeToken()}},A.prototype.consumeFunction=function(A){for(var e={name:A.value,values:[],type:18};;){var t=this.consumeToken();if(32===t.type||3===t.type)return e;this.reconsumeToken(t),e.values.push(this.consumeComponentValue())}},A.prototype.consumeToken=function(){var A=this._tokens.shift();return void 0===A?HA:A},A.prototype.reconsumeToken=function(A){this._tokens.unshift(A)},A}(),NA=function(A){return 15===A.type},OA=function(A){return 17===A.type},RA=function(A){return 20===A.type},PA=function(A){return 0===A.type},VA=function(A,e){return RA(A)&&A.value===e},KA=function(A){return 31!==A.type},GA=function(A){return 31!==A.type&&4!==A.type},WA=function(A){var e=[],t=[];return A.forEach((function(A){if(4===A.type){if(0===t.length)throw new Error("Error parsing function args, zero tokens for arg");return e.push(t),void(t=[])}31!==A.type&&t.push(A)})),t.length&&e.push(t),e},XA=function(A,e){return 11===e&&12===A.type||28===e&&29===A.type||2===e&&3===A.type},zA=function(A){return 17===A.type||15===A.type},YA=function(A){return 16===A.type||zA(A)},JA=function(A){return A.length>1?[A[0],A[1]]:[A[0]]},jA={type:17,number:0,flags:4},ZA={type:16,number:50,flags:4},qA={type:16,number:100,flags:4},_A=function(A,e,t){var i=A[0],n=A[1];return[$A(i,e),$A(void 0!==n?n:i,t)]},$A=function(A,e){if(16===A.type)return A.number/100*e;if(NA(A))switch(A.unit){case"rem":case"em":return 16*A.number;default:return A.number}return A.number},Ae="grad",ee="turn",te=function(A,e){if(15===e.type)switch(e.unit){case"deg":return Math.PI*e.number/180;case Ae:return Math.PI/200*e.number;case"rad":return e.number;case ee:return 2*Math.PI*e.number}throw new Error("Unsupported angle type")},ie=function(A){return 15===A.type&&("deg"===A.unit||A.unit===Ae||"rad"===A.unit||A.unit===ee)},ne=function(A){switch(A.filter(RA).map((function(A){return A.value})).join(" ")){case"to bottom right":case"to right bottom":case"left top":case"top left":return[jA,jA];case"to top":case"bottom":return ae(0);case"to bottom left":case"to left bottom":case"right top":case"top right":return[jA,qA];case"to right":case"left":return ae(90);case"to top left":case"to left top":case"right bottom":case"bottom right":return[qA,qA];case"to bottom":case"top":return ae(180);case"to top right":case"to right top":case"left bottom":case"bottom left":return[qA,jA];case"to left":case"right":return ae(270)}return 0},ae=function(A){return Math.PI*A/180},se=function(A,e){if(18===e.type){var t=ue[e.name];if(void 0===t)throw new Error('Attempting to parse an unsupported color function "'+e.name+'"');return t(A,e.values)}if(5===e.type){if(3===e.value.length){var i=e.value.substring(0,1),n=e.value.substring(1,2),a=e.value.substring(2,3);return le(parseInt(i+i,16),parseInt(n+n,16),parseInt(a+a,16),1)}if(4===e.value.length){i=e.value.substring(0,1),n=e.value.substring(1,2),a=e.value.substring(2,3);var s=e.value.substring(3,4);return le(parseInt(i+i,16),parseInt(n+n,16),parseInt(a+a,16),parseInt(s+s,16)/255)}if(6===e.value.length)return i=e.value.substring(0,2),n=e.value.substring(2,4),a=e.value.substring(4,6),le(parseInt(i,16),parseInt(n,16),parseInt(a,16),1);if(8===e.value.length)return i=e.value.substring(0,2),n=e.value.substring(2,4),a=e.value.substring(4,6),s=e.value.substring(6,8),le(parseInt(i,16),parseInt(n,16),parseInt(a,16),parseInt(s,16)/255)}if(20===e.type){var r=pe[e.value.toUpperCase()];if(void 0!==r)return r}return pe.TRANSPARENT},re=function(A){return 0==(255&A)},oe=function(A){var e=255&A,t=255&A>>8,i=255&A>>16,n=255&A>>24;return e<255?"rgba("+n+","+i+","+t+","+e/255+")":"rgb("+n+","+i+","+t+")"},le=function(A,e,t,i){return(A<<24|e<<16|t<<8|Math.round(255*i)<<0)>>>0},ce=function(A,e){if(17===A.type)return A.number;if(16===A.type){var t=3===e?1:255;return 3===e?A.number/100*t:Math.round(A.number/100*t)}return 0},de=function(A,e){var t=e.filter(GA);if(3===t.length){var i=t.map(ce),n=i[0],a=i[1],s=i[2];return le(n,a,s,1)}if(4===t.length){var r=t.map(ce),o=(n=r[0],a=r[1],s=r[2],r[3]);return le(n,a,s,o)}return 0};function he(A,e,t){return t<0&&(t+=1),t>=1&&(t-=1),t<1/6?(e-A)*t*6+A:t<.5?e:t<2/3?6*(e-A)*(2/3-t)+A:A}var ge=function(A,e){var t=e.filter(GA),i=t[0],n=t[1],a=t[2],s=t[3],r=(17===i.type?ae(i.number):te(A,i))/(2*Math.PI),o=YA(n)?n.number/100:0,l=YA(a)?a.number/100:0,c=void 0!==s&&YA(s)?$A(s,1):1;if(0===o)return le(255*l,255*l,255*l,1);var d=l<=.5?l*(o+1):l+o-l*o,h=2*l-d,g=he(h,d,r+1/3),u=he(h,d,r),w=he(h,d,r-1/3);return le(255*g,255*u,255*w,c)},ue={hsl:ge,hsla:ge,rgb:de,rgba:de},we=function(A,e){return se(A,kA.create(e).parseComponentValue())},pe={ALICEBLUE:4042850303,ANTIQUEWHITE:4209760255,AQUA:16777215,AQUAMARINE:2147472639,AZURE:4043309055,BEIGE:4126530815,BISQUE:4293182719,BLACK:255,BLANCHEDALMOND:4293643775,BLUE:65535,BLUEVIOLET:2318131967,BROWN:2771004159,BURLYWOOD:3736635391,CADETBLUE:1604231423,CHARTREUSE:2147418367,CHOCOLATE:3530104575,CORAL:4286533887,CORNFLOWERBLUE:1687547391,CORNSILK:4294499583,CRIMSON:3692313855,CYAN:16777215,DARKBLUE:35839,DARKCYAN:9145343,DARKGOLDENROD:3095837695,DARKGRAY:2846468607,DARKGREEN:6553855,DARKGREY:2846468607,DARKKHAKI:3182914559,DARKMAGENTA:2332068863,DARKOLIVEGREEN:1433087999,DARKORANGE:4287365375,DARKORCHID:2570243327,DARKRED:2332033279,DARKSALMON:3918953215,DARKSEAGREEN:2411499519,DARKSLATEBLUE:1211993087,DARKSLATEGRAY:793726975,DARKSLATEGREY:793726975,DARKTURQUOISE:13554175,DARKVIOLET:2483082239,DEEPPINK:4279538687,DEEPSKYBLUE:12582911,DIMGRAY:1768516095,DIMGREY:1768516095,DODGERBLUE:512819199,FIREBRICK:2988581631,FLORALWHITE:4294635775,FORESTGREEN:579543807,FUCHSIA:4278255615,GAINSBORO:3705462015,GHOSTWHITE:4177068031,GOLD:4292280575,GOLDENROD:3668254975,GRAY:2155905279,GREEN:8388863,GREENYELLOW:2919182335,GREY:2155905279,HONEYDEW:4043305215,HOTPINK:4285117695,INDIANRED:3445382399,INDIGO:1258324735,IVORY:4294963455,KHAKI:4041641215,LAVENDER:3873897215,LAVENDERBLUSH:4293981695,LAWNGREEN:2096890111,LEMONCHIFFON:4294626815,LIGHTBLUE:2916673279,LIGHTCORAL:4034953471,LIGHTCYAN:3774873599,LIGHTGOLDENRODYELLOW:4210742015,LIGHTGRAY:3553874943,LIGHTGREEN:2431553791,LIGHTGREY:3553874943,LIGHTPINK:4290167295,LIGHTSALMON:4288707327,LIGHTSEAGREEN:548580095,LIGHTSKYBLUE:2278488831,LIGHTSLATEGRAY:2005441023,LIGHTSLATEGREY:2005441023,LIGHTSTEELBLUE:2965692159,LIGHTYELLOW:4294959359,LIME:16711935,LIMEGREEN:852308735,LINEN:4210091775,MAGENTA:4278255615,MAROON:2147483903,MEDIUMAQUAMARINE:1724754687,MEDIUMBLUE:52735,MEDIUMORCHID:3126187007,MEDIUMPURPLE:2473647103,MEDIUMSEAGREEN:1018393087,MEDIUMSLATEBLUE:2070474495,MEDIUMSPRINGGREEN:16423679,MEDIUMTURQUOISE:1221709055,MEDIUMVIOLETRED:3340076543,MIDNIGHTBLUE:421097727,MINTCREAM:4127193855,MISTYROSE:4293190143,MOCCASIN:4293178879,NAVAJOWHITE:4292783615,NAVY:33023,OLDLACE:4260751103,OLIVE:2155872511,OLIVEDRAB:1804477439,ORANGE:4289003775,ORANGERED:4282712319,ORCHID:3664828159,PALEGOLDENROD:4008225535,PALEGREEN:2566625535,PALETURQUOISE:2951671551,PALEVIOLETRED:3681588223,PAPAYAWHIP:4293907967,PEACHPUFF:4292524543,PERU:3448061951,PINK:4290825215,PLUM:3718307327,POWDERBLUE:2967529215,PURPLE:2147516671,REBECCAPURPLE:1714657791,RED:4278190335,ROSYBROWN:3163525119,ROYALBLUE:1097458175,SADDLEBROWN:2336560127,SALMON:4202722047,SANDYBROWN:4104413439,SEAGREEN:780883967,SEASHELL:4294307583,SIENNA:2689740287,SILVER:3233857791,SKYBLUE:2278484991,SLATEBLUE:1784335871,SLATEGRAY:1887473919,SLATEGREY:1887473919,SNOW:4294638335,SPRINGGREEN:16744447,STEELBLUE:1182971135,TAN:3535047935,TEAL:8421631,THISTLE:3636451583,TOMATO:4284696575,TRANSPARENT:0,TURQUOISE:1088475391,VIOLET:4001558271,WHEAT:4125012991,WHITE:4294967295,WHITESMOKE:4126537215,YELLOW:4294902015,YELLOWGREEN:2597139199},Be={name:"background-clip",initialValue:"border-box",prefix:!1,type:1,parse:function(A,e){return e.map((function(A){if(RA(A))switch(A.value){case"padding-box":return 1;case"content-box":return 2}return 0}))}},me={name:"background-color",initialValue:"transparent",prefix:!1,type:3,format:"color"},fe=function(A,e){var t=se(A,e[0]),i=e[1];return i&&YA(i)?{color:t,stop:i}:{color:t,stop:null}},Ee=function(A,e){var t=A[0],i=A[A.length-1];null===t.stop&&(t.stop=jA),null===i.stop&&(i.stop=qA);for(var n=[],a=0,s=0;sa?n.push(o):n.push(a),a=o}else n.push(null)}var l=null;for(s=0;sA.optimumDistance)?{optimumCorner:e,optimumDistance:r}:A}),{optimumDistance:n?1/0:-1/0,optimumCorner:null}).optimumCorner},ye=function(A,e){var t=ae(180),i=[];return WA(e).forEach((function(e,n){if(0===n){var a=e[0];if(20===a.type&&-1!==["top","left","right","bottom"].indexOf(a.value))return void(t=ne(e));if(ie(a))return void(t=(te(A,a)+ae(270))%ae(360))}var s=fe(A,e);i.push(s)})),{angle:t,stops:i,type:1}},Qe="closest-side",be="farthest-side",Ue="closest-corner",xe="farthest-corner",Ie="circle",Se="ellipse",Te="cover",Le="contain",Me=function(A,e){var t=0,i=3,n=[],a=[];return WA(e).forEach((function(e,s){var r=!0;if(0===s?r=e.reduce((function(A,e){if(RA(e))switch(e.value){case"center":return a.push(ZA),!1;case"top":case"left":return a.push(jA),!1;case"right":case"bottom":return a.push(qA),!1}else if(YA(e)||zA(e))return a.push(e),!1;return A}),r):1===s&&(r=e.reduce((function(A,e){if(RA(e))switch(e.value){case Ie:return t=0,!1;case Se:return t=1,!1;case Le:case Qe:return i=0,!1;case be:return i=1,!1;case Ue:return i=2,!1;case Te:case xe:return i=3,!1}else if(zA(e)||YA(e))return Array.isArray(i)||(i=[]),i.push(e),!1;return A}),r)),r){var o=fe(A,e);n.push(o)}})),{size:i,shape:t,stops:n,position:a,type:2}},He=function(A,e){if(22===e.type){var t={url:e.value,type:0};return A.cache.addImage(e.value),t}if(18===e.type){var i=ke[e.name];if(void 0===i)throw new Error('Attempting to parse an unsupported image function "'+e.name+'"');return i(A,e.values)}throw new Error("Unsupported image type "+e.type)};var De,ke={"linear-gradient":function(A,e){var t=ae(180),i=[];return WA(e).forEach((function(e,n){if(0===n){var a=e[0];if(20===a.type&&"to"===a.value)return void(t=ne(e));if(ie(a))return void(t=te(A,a))}var s=fe(A,e);i.push(s)})),{angle:t,stops:i,type:1}},"-moz-linear-gradient":ye,"-ms-linear-gradient":ye,"-o-linear-gradient":ye,"-webkit-linear-gradient":ye,"radial-gradient":function(A,e){var t=0,i=3,n=[],a=[];return WA(e).forEach((function(e,s){var r=!0;if(0===s){var o=!1;r=e.reduce((function(A,e){if(o)if(RA(e))switch(e.value){case"center":return a.push(ZA),A;case"top":case"left":return a.push(jA),A;case"right":case"bottom":return a.push(qA),A}else(YA(e)||zA(e))&&a.push(e);else if(RA(e))switch(e.value){case Ie:return t=0,!1;case Se:return t=1,!1;case"at":return o=!0,!1;case Qe:return i=0,!1;case Te:case be:return i=1,!1;case Le:case Ue:return i=2,!1;case xe:return i=3,!1}else if(zA(e)||YA(e))return Array.isArray(i)||(i=[]),i.push(e),!1;return A}),r)}if(r){var l=fe(A,e);n.push(l)}})),{size:i,shape:t,stops:n,position:a,type:2}},"-moz-radial-gradient":Me,"-ms-radial-gradient":Me,"-o-radial-gradient":Me,"-webkit-radial-gradient":Me,"-webkit-gradient":function(A,e){var t=ae(180),i=[],n=1;return WA(e).forEach((function(e,t){var a=e[0];if(0===t){if(RA(a)&&"linear"===a.value)return void(n=1);if(RA(a)&&"radial"===a.value)return void(n=2)}if(18===a.type)if("from"===a.name){var s=se(A,a.values[0]);i.push({stop:jA,color:s})}else if("to"===a.name)s=se(A,a.values[0]),i.push({stop:qA,color:s});else if("color-stop"===a.name){var r=a.values.filter(GA);if(2===r.length){s=se(A,r[1]);var o=r[0];OA(o)&&i.push({stop:{type:16,number:100*o.number,flags:o.flags},color:s})}}})),1===n?{angle:(t+ae(180))%ae(360),stops:i,type:n}:{size:3,shape:0,stops:i,position:[],type:n}}},Ne={name:"background-image",initialValue:"none",type:1,prefix:!1,parse:function(A,e){if(0===e.length)return[];var t=e[0];return 20===t.type&&"none"===t.value?[]:e.filter((function(A){return GA(A)&&function(A){return!(20===A.type&&"none"===A.value||18===A.type&&!ke[A.name])}(A)})).map((function(e){return He(A,e)}))}},Oe={name:"background-origin",initialValue:"border-box",prefix:!1,type:1,parse:function(A,e){return e.map((function(A){if(RA(A))switch(A.value){case"padding-box":return 1;case"content-box":return 2}return 0}))}},Re={name:"background-position",initialValue:"0% 0%",type:1,prefix:!1,parse:function(A,e){return WA(e).map((function(A){return A.filter(YA)})).map(JA)}},Pe={name:"background-repeat",initialValue:"repeat",prefix:!1,type:1,parse:function(A,e){return WA(e).map((function(A){return A.filter(RA).map((function(A){return A.value})).join(" ")})).map(Ve)}},Ve=function(A){switch(A){case"no-repeat":return 1;case"repeat-x":case"repeat no-repeat":return 2;case"repeat-y":case"no-repeat repeat":return 3;default:return 0}};!function(A){A.AUTO="auto",A.CONTAIN="contain",A.COVER="cover"}(De||(De={}));var Ke,Ge={name:"background-size",initialValue:"0",prefix:!1,type:1,parse:function(A,e){return WA(e).map((function(A){return A.filter(We)}))}},We=function(A){return RA(A)||YA(A)},Xe=function(A){return{name:"border-"+A+"-color",initialValue:"transparent",prefix:!1,type:3,format:"color"}},ze=Xe("top"),Ye=Xe("right"),Je=Xe("bottom"),je=Xe("left"),Ze=function(A){return{name:"border-radius-"+A,initialValue:"0 0",prefix:!1,type:1,parse:function(A,e){return JA(e.filter(YA))}}},qe=Ze("top-left"),_e=Ze("top-right"),$e=Ze("bottom-right"),At=Ze("bottom-left"),et=function(A){return{name:"border-"+A+"-style",initialValue:"solid",prefix:!1,type:2,parse:function(A,e){switch(e){case"none":return 0;case"dashed":return 2;case"dotted":return 3;case"double":return 4}return 1}}},tt=et("top"),it=et("right"),nt=et("bottom"),at=et("left"),st=function(A){return{name:"border-"+A+"-width",initialValue:"0",type:0,prefix:!1,parse:function(A,e){return NA(e)?e.number:0}}},rt=st("top"),ot=st("right"),lt=st("bottom"),ct=st("left"),dt={name:"color",initialValue:"transparent",prefix:!1,type:3,format:"color"},ht={name:"direction",initialValue:"ltr",prefix:!1,type:2,parse:function(A,e){return"rtl"===e?1:0}},gt={name:"display",initialValue:"inline-block",prefix:!1,type:1,parse:function(A,e){return e.filter(RA).reduce((function(A,e){return A|ut(e.value)}),0)}},ut=function(A){switch(A){case"block":case"-webkit-box":return 2;case"inline":return 4;case"run-in":return 8;case"flow":return 16;case"flow-root":return 32;case"table":return 64;case"flex":case"-webkit-flex":return 128;case"grid":case"-ms-grid":return 256;case"ruby":return 512;case"subgrid":return 1024;case"list-item":return 2048;case"table-row-group":return 4096;case"table-header-group":return 8192;case"table-footer-group":return 16384;case"table-row":return 32768;case"table-cell":return 65536;case"table-column-group":return 131072;case"table-column":return 262144;case"table-caption":return 524288;case"ruby-base":return 1048576;case"ruby-text":return 2097152;case"ruby-base-container":return 4194304;case"ruby-text-container":return 8388608;case"contents":return 16777216;case"inline-block":return 33554432;case"inline-list-item":return 67108864;case"inline-table":return 134217728;case"inline-flex":return 268435456;case"inline-grid":return 536870912}return 0},wt={name:"float",initialValue:"none",prefix:!1,type:2,parse:function(A,e){switch(e){case"left":return 1;case"right":return 2;case"inline-start":return 3;case"inline-end":return 4}return 0}},pt={name:"letter-spacing",initialValue:"0",prefix:!1,type:0,parse:function(A,e){return 20===e.type&&"normal"===e.value?0:17===e.type||15===e.type?e.number:0}};!function(A){A.NORMAL="normal",A.STRICT="strict"}(Ke||(Ke={}));var Bt,mt={name:"line-break",initialValue:"normal",prefix:!1,type:2,parse:function(A,e){return"strict"===e?Ke.STRICT:Ke.NORMAL}},ft={name:"line-height",initialValue:"normal",prefix:!1,type:4},Et=function(A,e){return RA(A)&&"normal"===A.value?1.2*e:17===A.type?e*A.number:YA(A)?$A(A,e):e},Ct={name:"list-style-image",initialValue:"none",type:0,prefix:!1,parse:function(A,e){return 20===e.type&&"none"===e.value?null:He(A,e)}},Ft={name:"list-style-position",initialValue:"outside",prefix:!1,type:2,parse:function(A,e){return"inside"===e?0:1}},vt={name:"list-style-type",initialValue:"none",prefix:!1,type:2,parse:function(A,e){switch(e){case"disc":return 0;case"circle":return 1;case"square":return 2;case"decimal":return 3;case"cjk-decimal":return 4;case"decimal-leading-zero":return 5;case"lower-roman":return 6;case"upper-roman":return 7;case"lower-greek":return 8;case"lower-alpha":return 9;case"upper-alpha":return 10;case"arabic-indic":return 11;case"armenian":return 12;case"bengali":return 13;case"cambodian":return 14;case"cjk-earthly-branch":return 15;case"cjk-heavenly-stem":return 16;case"cjk-ideographic":return 17;case"devanagari":return 18;case"ethiopic-numeric":return 19;case"georgian":return 20;case"gujarati":return 21;case"gurmukhi":case"hebrew":return 22;case"hiragana":return 23;case"hiragana-iroha":return 24;case"japanese-formal":return 25;case"japanese-informal":return 26;case"kannada":return 27;case"katakana":return 28;case"katakana-iroha":return 29;case"khmer":return 30;case"korean-hangul-formal":return 31;case"korean-hanja-formal":return 32;case"korean-hanja-informal":return 33;case"lao":return 34;case"lower-armenian":return 35;case"malayalam":return 36;case"mongolian":return 37;case"myanmar":return 38;case"oriya":return 39;case"persian":return 40;case"simp-chinese-formal":return 41;case"simp-chinese-informal":return 42;case"tamil":return 43;case"telugu":return 44;case"thai":return 45;case"tibetan":return 46;case"trad-chinese-formal":return 47;case"trad-chinese-informal":return 48;case"upper-armenian":return 49;case"disclosure-open":return 50;case"disclosure-closed":return 51;default:return-1}}},yt=function(A){return{name:"margin-"+A,initialValue:"0",prefix:!1,type:4}},Qt=yt("top"),bt=yt("right"),Ut=yt("bottom"),xt=yt("left"),It={name:"overflow",initialValue:"visible",prefix:!1,type:1,parse:function(A,e){return e.filter(RA).map((function(A){switch(A.value){case"hidden":return 1;case"scroll":return 2;case"clip":return 3;case"auto":return 4;default:return 0}}))}},St={name:"overflow-wrap",initialValue:"normal",prefix:!1,type:2,parse:function(A,e){return"break-word"===e?"break-word":"normal"}},Tt=function(A){return{name:"padding-"+A,initialValue:"0",prefix:!1,type:3,format:"length-percentage"}},Lt=Tt("top"),Mt=Tt("right"),Ht=Tt("bottom"),Dt=Tt("left"),kt={name:"text-align",initialValue:"left",prefix:!1,type:2,parse:function(A,e){switch(e){case"right":return 2;case"center":case"justify":return 1;default:return 0}}},Nt={name:"position",initialValue:"static",prefix:!1,type:2,parse:function(A,e){switch(e){case"relative":return 1;case"absolute":return 2;case"fixed":return 3;case"sticky":return 4}return 0}},Ot={name:"text-shadow",initialValue:"none",type:1,prefix:!1,parse:function(A,e){return 1===e.length&&VA(e[0],"none")?[]:WA(e).map((function(e){for(var t={color:pe.TRANSPARENT,offsetX:jA,offsetY:jA,blur:jA},i=0,n=0;n1?1:0],this.overflowWrap=Bi(A,St,e.overflowWrap),this.paddingTop=Bi(A,Lt,e.paddingTop),this.paddingRight=Bi(A,Mt,e.paddingRight),this.paddingBottom=Bi(A,Ht,e.paddingBottom),this.paddingLeft=Bi(A,Dt,e.paddingLeft),this.paintOrder=Bi(A,di,e.paintOrder),this.position=Bi(A,Nt,e.position),this.textAlign=Bi(A,kt,e.textAlign),this.textDecorationColor=Bi(A,Zt,null!==(t=e.textDecorationColor)&&void 0!==t?t:e.color),this.textDecorationLine=Bi(A,qt,null!==(i=e.textDecorationLine)&&void 0!==i?i:e.textDecoration),this.textShadow=Bi(A,Ot,e.textShadow),this.textTransform=Bi(A,Rt,e.textTransform),this.transform=Bi(A,Pt,e.transform),this.transformOrigin=Bi(A,Wt,e.transformOrigin),this.visibility=Bi(A,Xt,e.visibility),this.webkitTextStrokeColor=Bi(A,hi,e.webkitTextStrokeColor),this.webkitTextStrokeWidth=Bi(A,gi,e.webkitTextStrokeWidth),this.wordBreak=Bi(A,zt,e.wordBreak),this.zIndex=Bi(A,Yt,e.zIndex)}return A.prototype.isVisible=function(){return this.display>0&&this.opacity>0&&0===this.visibility},A.prototype.isTransparent=function(){return re(this.backgroundColor)},A.prototype.isTransformed=function(){return null!==this.transform},A.prototype.isPositioned=function(){return 0!==this.position},A.prototype.isPositionedWithZIndex=function(){return this.isPositioned()&&!this.zIndex.auto},A.prototype.isFloating=function(){return 0!==this.float},A.prototype.isInlineLevel=function(){return ii(this.display,4)||ii(this.display,33554432)||ii(this.display,268435456)||ii(this.display,536870912)||ii(this.display,67108864)||ii(this.display,134217728)},A}(),wi=function(A,e){this.content=Bi(A,ni,e.content),this.quotes=Bi(A,oi,e.quotes)},pi=function(A,e){this.counterIncrement=Bi(A,ai,e.counterIncrement),this.counterReset=Bi(A,si,e.counterReset)},Bi=function(A,e,t){var i=new DA,n=null!=t?t.toString():e.initialValue;i.write(n);var a=new kA(i.read());switch(e.type){case 2:var s=a.parseComponentValue();return e.parse(A,RA(s)?s.value:e.initialValue);case 0:return e.parse(A,a.parseComponentValue());case 1:return e.parse(A,a.parseComponentValues());case 4:return a.parseComponentValue();case 3:switch(e.format){case"angle":return te(A,a.parseComponentValue());case"color":return se(A,a.parseComponentValue());case"image":return He(A,a.parseComponentValue());case"length":var r=a.parseComponentValue();return zA(r)?r:jA;case"length-percentage":var o=a.parseComponentValue();return YA(o)?o:jA;case"time":return Jt.parse(A,a.parseComponentValue())}}},mi=function(A,e){var t=function(A){switch(A.getAttribute("data-html2canvas-debug")){case"all":return 1;case"clone":return 2;case"parse":return 3;case"render":return 4;default:return 0}}(A);return 1===t||e===t},fi=function(A,e){this.context=A,this.textNodes=[],this.elements=[],this.flags=0,mi(e,3),this.styles=new ui(A,window.getComputedStyle(e,null)),yn(e)&&(this.styles.animationDuration.some((function(A){return A>0}))&&(e.style.animationDuration="0s"),null!==this.styles.transform&&(e.style.transform="none")),this.bounds=r(this.context,e),mi(e,4)&&(this.flags|=16)},Ei="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",Ci="undefined"==typeof Uint8Array?[]:new Uint8Array(256),Fi=0;Fi=0){if(A<55296||A>56319&&A<=65535)return e=((e=this.index[A>>5])<<2)+(31&A),this.data[e];if(A<=65535)return e=((e=this.index[2048+(A-55296>>5)])<<2)+(31&A),this.data[e];if(A>11),e=this.index[e],e+=A>>5&63,e=((e=this.index[e])<<2)+(31&A),this.data[e];if(A<=1114111)return this.data[this.highValueIndex]}return this.errorValue},A}(),Qi="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",bi="undefined"==typeof Uint8Array?[]:new Uint8Array(256),Ui=0;Ui>10),s%1024+56320)),(n+1===t||i.length>16384)&&(a+=String.fromCharCode.apply(String,i),i.length=0)}return a},Hi=function(A,e){var t,i,n,a=function(A){var e,t,i,n,a,s=.75*A.length,r=A.length,o=0;"="===A[A.length-1]&&(s--,"="===A[A.length-2]&&s--);var l="undefined"!=typeof ArrayBuffer&&"undefined"!=typeof Uint8Array&&void 0!==Uint8Array.prototype.slice?new ArrayBuffer(s):new Array(s),c=Array.isArray(l)?l:new Uint8Array(l);for(e=0;e>4,c[o++]=(15&i)<<4|n>>2,c[o++]=(3&n)<<6|63&a;return l}(A),s=Array.isArray(a)?function(A){for(var e=A.length,t=[],i=0;i=55296&&n<=56319&&t=t)return{done:!0,value:null};for(var A=Di;is.x||n.y>s.y;return s=n,0===e||r}));return A.body.removeChild(e),r}(document);return Object.defineProperty(Ki,"SUPPORT_WORD_BREAKING",{value:A}),A},get SUPPORT_SVG_DRAWING(){var A=function(A){var e=new Image,t=A.createElement("canvas"),i=t.getContext("2d");if(!i)return!1;e.src="data:image/svg+xml,";try{i.drawImage(e,0,0),t.toDataURL()}catch(A){return!1}return!0}(document);return Object.defineProperty(Ki,"SUPPORT_SVG_DRAWING",{value:A}),A},get SUPPORT_FOREIGNOBJECT_DRAWING(){var A="function"==typeof Array.from&&"function"==typeof window.fetch?function(A){var e=A.createElement("canvas"),t=100;e.width=t,e.height=t;var i=e.getContext("2d");if(!i)return Promise.reject(!1);i.fillStyle="rgb(0, 255, 0)",i.fillRect(0,0,t,t);var n=new Image,a=e.toDataURL();n.src=a;var s=Pi(t,t,0,0,n);return i.fillStyle="red",i.fillRect(0,0,t,t),Vi(s).then((function(e){i.drawImage(e,0,0);var n=i.getImageData(0,0,t,t).data;i.fillStyle="red",i.fillRect(0,0,t,t);var s=A.createElement("div");return s.style.backgroundImage="url("+a+")",s.style.height="100px",Ri(n)?Vi(Pi(t,t,0,0,s)):Promise.reject(!1)})).then((function(A){return i.drawImage(A,0,0),Ri(i.getImageData(0,0,t,t).data)})).catch((function(){return!1}))}(document):Promise.resolve(!1);return Object.defineProperty(Ki,"SUPPORT_FOREIGNOBJECT_DRAWING",{value:A}),A},get SUPPORT_CORS_IMAGES(){var A=void 0!==(new Image).crossOrigin;return Object.defineProperty(Ki,"SUPPORT_CORS_IMAGES",{value:A}),A},get SUPPORT_RESPONSE_TYPE(){var A="string"==typeof(new XMLHttpRequest).responseType;return Object.defineProperty(Ki,"SUPPORT_RESPONSE_TYPE",{value:A}),A},get SUPPORT_CORS_XHR(){var A="withCredentials"in new XMLHttpRequest;return Object.defineProperty(Ki,"SUPPORT_CORS_XHR",{value:A}),A},get SUPPORT_NATIVE_TEXT_SEGMENTATION(){var A=!("undefined"==typeof Intl||!Intl.Segmenter);return Object.defineProperty(Ki,"SUPPORT_NATIVE_TEXT_SEGMENTATION",{value:A}),A}},Gi=function(A,e){this.text=A,this.bounds=e},Wi=function(A,e){var t=e.ownerDocument;if(t){var i=t.createElement("html2canvaswrapper");i.appendChild(e.cloneNode(!0));var n=e.parentNode;if(n){n.replaceChild(i,e);var a=r(A,i);return i.firstChild&&n.replaceChild(i.firstChild,i),a}}return s.EMPTY},Xi=function(A,e,t){var i=A.ownerDocument;if(!i)throw new Error("Node has no owner document");var n=i.createRange();return n.setStart(A,e),n.setEnd(A,e+t),n},zi=function(A){if(Ki.SUPPORT_NATIVE_TEXT_SEGMENTATION){var e=new Intl.Segmenter(void 0,{granularity:"grapheme"});return Array.from(e.segment(A)).map((function(A){return A.segment}))}return function(A){for(var e,t=Oi(A),i=[];!(e=t.next()).done;)e.value&&i.push(e.value.slice());return i}(A)},Yi=function(A,e){return 0!==e.letterSpacing?zi(A):function(A,e){if(Ki.SUPPORT_NATIVE_TEXT_SEGMENTATION){var t=new Intl.Segmenter(void 0,{granularity:"word"});return Array.from(t.segment(A)).map((function(A){return A.segment}))}return ji(A,e)}(A,e)},Ji=[32,160,4961,65792,65793,4153,4241],ji=function(A,e){for(var t,i=function(A,e){var t=o(A),i=$(t,e),n=i[0],a=i[1],s=i[2],r=t.length,l=0,c=0;return{next:function(){if(c>=r)return{done:!0,value:null};for(var A=P;c0)if(Ki.SUPPORT_RANGE_BOUNDS){var n=Xi(i,r,e.length).getClientRects();if(n.length>1){var o=zi(e),l=0;o.forEach((function(e){a.push(new Gi(e,s.fromDOMRectList(A,Xi(i,l+r,e.length).getClientRects()))),l+=e.length}))}else a.push(new Gi(e,s.fromDOMRectList(A,n)))}else{var c=i.splitText(e.length);a.push(new Gi(e,Wi(A,i))),i=c}else Ki.SUPPORT_RANGE_BOUNDS||(i=i.splitText(e.length));r+=e.length})),a}(A,this.text,t,e)},qi=function(A,e){switch(e){case 1:return A.toLowerCase();case 3:return A.replace(_i,$i);case 2:return A.toUpperCase();default:return A}},_i=/(^|\s|:|-|\(|\))([a-z])/g,$i=function(A,e,t){return A.length>0?e+t.toUpperCase():A},An=function(A){function t(e,t){var i=A.call(this,e,t)||this;return i.src=t.currentSrc||t.src,i.intrinsicWidth=t.naturalWidth,i.intrinsicHeight=t.naturalHeight,i.context.cache.addImage(i.src),i}return e(t,A),t}(fi),en=function(A){function t(e,t){var i=A.call(this,e,t)||this;return i.canvas=t,i.intrinsicWidth=t.width,i.intrinsicHeight=t.height,i}return e(t,A),t}(fi),tn=function(A){function t(e,t){var i=A.call(this,e,t)||this,n=new XMLSerializer,a=r(e,t);return t.setAttribute("width",a.width+"px"),t.setAttribute("height",a.height+"px"),i.svg="data:image/svg+xml,"+encodeURIComponent(n.serializeToString(t)),i.intrinsicWidth=t.width.baseVal.value,i.intrinsicHeight=t.height.baseVal.value,i.context.cache.addImage(i.svg),i}return e(t,A),t}(fi),nn=function(A){function t(e,t){var i=A.call(this,e,t)||this;return i.value=t.value,i}return e(t,A),t}(fi),an=function(A){function t(e,t){var i=A.call(this,e,t)||this;return i.start=t.start,i.reversed="boolean"==typeof t.reversed&&!0===t.reversed,i}return e(t,A),t}(fi),sn=[{type:15,flags:0,unit:"px",number:3}],rn=[{type:16,flags:0,number:50}],on="checkbox",ln="radio",cn="password",dn=707406591,hn=function(A){function t(e,t){var i,n,a,r=A.call(this,e,t)||this;switch(r.type=t.type.toLowerCase(),r.checked=t.checked,r.value=0===(a=(n=t).type===cn?new Array(n.value.length+1).join("•"):n.value).length?n.placeholder||"":a,r.type!==on&&r.type!==ln||(r.styles.backgroundColor=3739148031,r.styles.borderTopColor=r.styles.borderRightColor=r.styles.borderBottomColor=r.styles.borderLeftColor=2779096575,r.styles.borderTopWidth=r.styles.borderRightWidth=r.styles.borderBottomWidth=r.styles.borderLeftWidth=1,r.styles.borderTopStyle=r.styles.borderRightStyle=r.styles.borderBottomStyle=r.styles.borderLeftStyle=1,r.styles.backgroundClip=[0],r.styles.backgroundOrigin=[0],r.bounds=(i=r.bounds).width>i.height?new s(i.left+(i.width-i.height)/2,i.top,i.height,i.height):i.width0)t.textNodes.push(new Zi(A,n,t.styles));else if(vn(n))if(Nn(n)&&n.assignedNodes)n.assignedNodes().forEach((function(e){return Bn(A,e,t,i)}));else{var s=mn(A,n);s.styles.isVisible()&&(En(n,s,i)?s.flags|=4:Cn(s.styles)&&(s.flags|=2),-1!==pn.indexOf(n.tagName)&&(s.flags|=8),t.elements.push(s),n.slot,n.shadowRoot?Bn(A,n.shadowRoot,s,i):Dn(n)||In(n)||kn(n)||Bn(A,n,s,i))}},mn=function(A,e){return Ln(e)?new An(A,e):Tn(e)?new en(A,e):In(e)?new tn(A,e):bn(e)?new nn(A,e):Un(e)?new an(A,e):xn(e)?new hn(A,e):kn(e)?new gn(A,e):Dn(e)?new un(A,e):Mn(e)?new wn(A,e):new fi(A,e)},fn=function(A,e){var t=mn(A,e);return t.flags|=4,Bn(A,e,t,t),t},En=function(A,e,t){return e.styles.isPositionedWithZIndex()||e.styles.opacity<1||e.styles.isTransformed()||Sn(A)&&t.styles.isTransparent()},Cn=function(A){return A.isPositioned()||A.isFloating()},Fn=function(A){return A.nodeType===Node.TEXT_NODE},vn=function(A){return A.nodeType===Node.ELEMENT_NODE},yn=function(A){return vn(A)&&void 0!==A.style&&!Qn(A)},Qn=function(A){return"object"==typeof A.className},bn=function(A){return"LI"===A.tagName},Un=function(A){return"OL"===A.tagName},xn=function(A){return"INPUT"===A.tagName},In=function(A){return"svg"===A.tagName},Sn=function(A){return"BODY"===A.tagName},Tn=function(A){return"CANVAS"===A.tagName},Ln=function(A){return"IMG"===A.tagName},Mn=function(A){return"IFRAME"===A.tagName},Hn=function(A){return"STYLE"===A.tagName},Dn=function(A){return"TEXTAREA"===A.tagName},kn=function(A){return"SELECT"===A.tagName},Nn=function(A){return"SLOT"===A.tagName},On=function(A){return A.tagName.indexOf("-")>0},Rn=function(){function A(){this.counters={}}return A.prototype.getCounterValue=function(A){var e=this.counters[A];return e&&e.length?e[e.length-1]:1},A.prototype.getCounterValues=function(A){return this.counters[A]||[]},A.prototype.pop=function(A){var e=this;A.forEach((function(A){return e.counters[A].pop()}))},A.prototype.parse=function(A){var e=this,t=A.counterIncrement,i=A.counterReset,n=!0;null!==t&&t.forEach((function(A){var t=e.counters[A.counter];t&&0!==A.increment&&(n=!1,t.length||t.push(1),t[Math.max(0,t.length-1)]+=A.increment)}));var a=[];return n&&i.forEach((function(A){var t=e.counters[A.counter];a.push(A.counter),t||(t=e.counters[A.counter]=[]),t.push(A.reset)})),a},A}(),Pn={integers:[1e3,900,500,400,100,90,50,40,10,9,5,4,1],values:["M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"]},Vn={integers:[9e3,8e3,7e3,6e3,5e3,4e3,3e3,2e3,1e3,900,800,700,600,500,400,300,200,100,90,80,70,60,50,40,30,20,10,9,8,7,6,5,4,3,2,1],values:["Ք","Փ","Ւ","Ց","Ր","Տ","Վ","Ս","Ռ","Ջ","Պ","Չ","Ո","Շ","Ն","Յ","Մ","Ճ","Ղ","Ձ","Հ","Կ","Ծ","Խ","Լ","Ի","Ժ","Թ","Ը","Է","Զ","Ե","Դ","Գ","Բ","Ա"]},Kn={integers:[1e4,9e3,8e3,7e3,6e3,5e3,4e3,3e3,2e3,1e3,400,300,200,100,90,80,70,60,50,40,30,20,19,18,17,16,15,10,9,8,7,6,5,4,3,2,1],values:["י׳","ט׳","ח׳","ז׳","ו׳","ה׳","ד׳","ג׳","ב׳","א׳","ת","ש","ר","ק","צ","פ","ע","ס","נ","מ","ל","כ","יט","יח","יז","טז","טו","י","ט","ח","ז","ו","ה","ד","ג","ב","א"]},Gn={integers:[1e4,9e3,8e3,7e3,6e3,5e3,4e3,3e3,2e3,1e3,900,800,700,600,500,400,300,200,100,90,80,70,60,50,40,30,20,10,9,8,7,6,5,4,3,2,1],values:["ჵ","ჰ","ჯ","ჴ","ხ","ჭ","წ","ძ","ც","ჩ","შ","ყ","ღ","ქ","ფ","ჳ","ტ","ს","რ","ჟ","პ","ო","ჲ","ნ","მ","ლ","კ","ი","თ","ჱ","ზ","ვ","ე","დ","გ","ბ","ა"]},Wn=function(A,e,t,i,n,a){return At?$n(A,n,a.length>0):i.integers.reduce((function(e,t,n){for(;A>=t;)A-=t,e+=i.values[n];return e}),"")+a},Xn=function(A,e,t,i){var n="";do{t||A--,n=i(A)+n,A/=e}while(A*e>=e);return n},zn=function(A,e,t,i,n){var a=t-e+1;return(A<0?"-":"")+(Xn(Math.abs(A),a,i,(function(A){return l(Math.floor(A%a)+e)}))+n)},Yn=function(A,e,t){void 0===t&&(t=". ");var i=e.length;return Xn(Math.abs(A),i,!1,(function(A){return e[Math.floor(A%i)]}))+t},Jn=function(A,e,t,i,n,a){if(A<-9999||A>9999)return $n(A,4,n.length>0);var s=Math.abs(A),r=n;if(0===s)return e[0]+r;for(var o=0;s>0&&o<=4;o++){var l=s%10;0===l&&ii(a,1)&&""!==r?r=e[l]+r:l>1||1===l&&0===o||1===l&&1===o&&ii(a,2)||1===l&&1===o&&ii(a,4)&&A>100||1===l&&o>1&&ii(a,8)?r=e[l]+(o>0?t[o-1]:"")+r:1===l&&o>0&&(r=t[o-1]+r),s=Math.floor(s/10)}return(A<0?i:"")+r},jn="十百千萬",Zn="拾佰仟萬",qn="マイナス",_n="마이너스",$n=function(A,e,t){var i=t?". ":"",n=t?"、":"",a=t?", ":"",s=t?" ":"";switch(e){case 0:return"•"+s;case 1:return"◦"+s;case 2:return"◾"+s;case 5:var r=zn(A,48,57,!0,i);return r.length<4?"0"+r:r;case 4:return Yn(A,"〇一二三四五六七八九",n);case 6:return Wn(A,1,3999,Pn,3,i).toLowerCase();case 7:return Wn(A,1,3999,Pn,3,i);case 8:return zn(A,945,969,!1,i);case 9:return zn(A,97,122,!1,i);case 10:return zn(A,65,90,!1,i);case 11:return zn(A,1632,1641,!0,i);case 12:case 49:return Wn(A,1,9999,Vn,3,i);case 35:return Wn(A,1,9999,Vn,3,i).toLowerCase();case 13:return zn(A,2534,2543,!0,i);case 14:case 30:return zn(A,6112,6121,!0,i);case 15:return Yn(A,"子丑寅卯辰巳午未申酉戌亥",n);case 16:return Yn(A,"甲乙丙丁戊己庚辛壬癸",n);case 17:case 48:return Jn(A,"零一二三四五六七八九",jn,"負",n,14);case 47:return Jn(A,"零壹貳參肆伍陸柒捌玖",Zn,"負",n,15);case 42:return Jn(A,"零一二三四五六七八九",jn,"负",n,14);case 41:return Jn(A,"零壹贰叁肆伍陆柒捌玖",Zn,"负",n,15);case 26:return Jn(A,"〇一二三四五六七八九","十百千万",qn,n,0);case 25:return Jn(A,"零壱弐参四伍六七八九","拾百千万",qn,n,7);case 31:return Jn(A,"영일이삼사오육칠팔구","십백천만",_n,a,7);case 33:return Jn(A,"零一二三四五六七八九","十百千萬",_n,a,0);case 32:return Jn(A,"零壹貳參四五六七八九","拾百千",_n,a,7);case 18:return zn(A,2406,2415,!0,i);case 20:return Wn(A,1,19999,Gn,3,i);case 21:return zn(A,2790,2799,!0,i);case 22:return zn(A,2662,2671,!0,i);case 22:return Wn(A,1,10999,Kn,3,i);case 23:return Yn(A,"あいうえおかきくけこさしすせそたちつてとなにぬねのはひふへほまみむめもやゆよらりるれろわゐゑをん");case 24:return Yn(A,"いろはにほへとちりぬるをわかよたれそつねならむうゐのおくやまけふこえてあさきゆめみしゑひもせす");case 27:return zn(A,3302,3311,!0,i);case 28:return Yn(A,"アイウエオカキクケコサシスセソタチツテトナニヌネノハヒフヘホマミムメモヤユヨラリルレロワヰヱヲン",n);case 29:return Yn(A,"イロハニホヘトチリヌルヲワカヨタレソツネナラムウヰノオクヤマケフコエテアサキユメミシヱヒモセス",n);case 34:return zn(A,3792,3801,!0,i);case 37:return zn(A,6160,6169,!0,i);case 38:return zn(A,4160,4169,!0,i);case 39:return zn(A,2918,2927,!0,i);case 40:return zn(A,1776,1785,!0,i);case 43:return zn(A,3046,3055,!0,i);case 44:return zn(A,3174,3183,!0,i);case 45:return zn(A,3664,3673,!0,i);case 46:return zn(A,3872,3881,!0,i);default:return zn(A,48,57,!0,i)}},Aa="data-html2canvas-ignore",ea=function(){function A(A,e,t){if(this.context=A,this.options=t,this.scrolledElements=[],this.referenceElement=e,this.counters=new Rn,this.quoteDepth=0,!e.ownerDocument)throw new Error("Cloned element does not have an owner document");this.documentElement=this.cloneNode(e.ownerDocument.documentElement,!1)}return A.prototype.toIFrame=function(A,e){var t=this,a=ia(A,e);if(!a.contentWindow)return Promise.reject("Unable to find iframe window");var s=A.defaultView.pageXOffset,r=A.defaultView.pageYOffset,o=a.contentWindow,l=o.document,c=sa(a).then((function(){return i(t,void 0,void 0,(function(){var A,t;return n(this,(function(i){switch(i.label){case 0:return this.scrolledElements.forEach(da),o&&(o.scrollTo(e.left,e.top),!/(iPad|iPhone|iPod)/g.test(navigator.userAgent)||o.scrollY===e.top&&o.scrollX===e.left||(this.context.logger.warn("Unable to restore scroll position for cloned document"),this.context.windowBounds=this.context.windowBounds.add(o.scrollX-e.left,o.scrollY-e.top,0,0))),A=this.options.onclone,void 0===(t=this.clonedReferenceElement)?[2,Promise.reject("Error finding the "+this.referenceElement.nodeName+" in the cloned document")]:l.fonts&&l.fonts.ready?[4,l.fonts.ready]:[3,2];case 1:i.sent(),i.label=2;case 2:return/(AppleWebKit)/g.test(navigator.userAgent)?[4,aa(l)]:[3,4];case 3:i.sent(),i.label=4;case 4:return"function"==typeof A?[2,Promise.resolve().then((function(){return A(l,t)})).then((function(){return a}))]:[2,a]}}))}))}));return l.open(),l.write(la(document.doctype)+""),ca(this.referenceElement.ownerDocument,s,r),l.replaceChild(l.adoptNode(this.documentElement),l.documentElement),l.close(),c},A.prototype.createElementClone=function(A){if(mi(A,2),Tn(A))return this.createCanvasClone(A);if(Hn(A))return this.createStyleClone(A);var e=A.cloneNode(!1);return Ln(e)&&(Ln(A)&&A.currentSrc&&A.currentSrc!==A.src&&(e.src=A.currentSrc,e.srcset=""),"lazy"===e.loading&&(e.loading="eager")),On(e)?this.createCustomElementClone(e):e},A.prototype.createCustomElementClone=function(A){var e=document.createElement("html2canvascustomelement");return oa(A.style,e),e},A.prototype.createStyleClone=function(A){try{var e=A.sheet;if(e&&e.cssRules){var t=[].slice.call(e.cssRules,0).reduce((function(A,e){return e&&"string"==typeof e.cssText?A+e.cssText:A}),""),i=A.cloneNode(!1);return i.textContent=t,i}}catch(A){if(this.context.logger.error("Unable to access cssRules property",A),"SecurityError"!==A.name)throw A}return A.cloneNode(!1)},A.prototype.createCanvasClone=function(A){var e;if(this.options.inlineImages&&A.ownerDocument){var t=A.ownerDocument.createElement("img");try{return t.src=A.toDataURL(),t}catch(e){this.context.logger.info("Unable to inline canvas contents, canvas is tainted",A)}}var i=A.cloneNode(!1);try{i.width=A.width,i.height=A.height;var n=A.getContext("2d"),a=i.getContext("2d");if(a)if(!this.options.allowTaint&&n)a.putImageData(n.getImageData(0,0,A.width,A.height),0,0);else{var s=null!==(e=A.getContext("webgl2"))&&void 0!==e?e:A.getContext("webgl");if(s){var r=s.getContextAttributes();!1===(null==r?void 0:r.preserveDrawingBuffer)&&this.context.logger.warn("Unable to clone WebGL context as it has preserveDrawingBuffer=false",A)}a.drawImage(A,0,0)}return i}catch(e){this.context.logger.info("Unable to clone canvas as it is tainted",A)}return i},A.prototype.appendChildNode=function(A,e,t){vn(e)&&("SCRIPT"===e.tagName||e.hasAttribute(Aa)||"function"==typeof this.options.ignoreElements&&this.options.ignoreElements(e))||this.options.copyStyles&&vn(e)&&Hn(e)||A.appendChild(this.cloneNode(e,t))},A.prototype.cloneNode=function(A,e){var t=this;if(Fn(A))return document.createTextNode(A.data);if(!A.ownerDocument)return A.cloneNode(!1);var i=A.ownerDocument.defaultView;if(i&&vn(A)&&(yn(A)||Qn(A))){var n=this.createElementClone(A);n.style.transitionProperty="none";var a=i.getComputedStyle(A),s=i.getComputedStyle(A,":before"),r=i.getComputedStyle(A,":after");this.referenceElement===A&&yn(n)&&(this.clonedReferenceElement=n),Sn(n)&&wa(n);var o=this.counters.parse(new pi(this.context,a)),l=this.resolvePseudoContent(A,n,s,xi.BEFORE);On(A)&&(e=!0);for(var c=A.shadowRoot?A.shadowRoot.firstChild:A.firstChild;c;c=c.nextSibling)if(vn(c)&&Nn(c)&&"function"==typeof c.assignedNodes){var d=c.assignedNodes();d.length&&d.forEach((function(A){return t.appendChildNode(n,A,e)}))}else this.appendChildNode(n,c,e);l&&n.insertBefore(l,n.firstChild);var h=this.resolvePseudoContent(A,n,r,xi.AFTER);return h&&n.appendChild(h),this.counters.pop(o),(a&&(this.options.copyStyles||Qn(A))&&!Mn(A)||e)&&oa(a,n),0===A.scrollTop&&0===A.scrollLeft||this.scrolledElements.push([n,A.scrollLeft,A.scrollTop]),(Dn(A)||kn(A))&&(Dn(n)||kn(n))&&(n.value=A.value),n}return A.cloneNode(!1)},A.prototype.resolvePseudoContent=function(A,e,t,i){var n=this;if(t){var a=t.content,s=e.ownerDocument;if(s&&a&&"none"!==a&&"-moz-alt-content"!==a&&"none"!==t.display){this.counters.parse(new pi(this.context,t));var r=new wi(this.context,t),o=s.createElement("html2canvaspseudoelement");oa(t,o),r.content.forEach((function(e){if(0===e.type)o.appendChild(s.createTextNode(e.value));else if(22===e.type){var t=s.createElement("img");t.src=e.value,t.style.opacity="1",o.appendChild(t)}else if(18===e.type){if("attr"===e.name){var i=e.values.filter(RA);i.length&&o.appendChild(s.createTextNode(A.getAttribute(i[0].value)||""))}else if("counter"===e.name){var a=e.values.filter(GA),l=a[0],c=a[1];if(l&&RA(l)){var d=n.counters.getCounterValue(l.value),h=c&&RA(c)?vt.parse(n.context,c.value):3;o.appendChild(s.createTextNode($n(d,h,!1)))}}else if("counters"===e.name){var g=e.values.filter(GA),u=(l=g[0],g[1]);if(c=g[2],l&&RA(l)){var w=n.counters.getCounterValues(l.value),p=c&&RA(c)?vt.parse(n.context,c.value):3,B=u&&0===u.type?u.value:"",m=w.map((function(A){return $n(A,p,!1)})).join(B);o.appendChild(s.createTextNode(m))}}}else if(20===e.type)switch(e.value){case"open-quote":o.appendChild(s.createTextNode(li(r.quotes,n.quoteDepth++,!0)));break;case"close-quote":o.appendChild(s.createTextNode(li(r.quotes,--n.quoteDepth,!1)));break;default:o.appendChild(s.createTextNode(e.value))}})),o.className=ha+" "+ga;var l=i===xi.BEFORE?" "+ha:" "+ga;return Qn(e)?e.className.baseValue+=l:e.className+=l,o}}},A.destroy=function(A){return!!A.parentNode&&(A.parentNode.removeChild(A),!0)},A}();!function(A){A[A.BEFORE=0]="BEFORE",A[A.AFTER=1]="AFTER"}(xi||(xi={}));var ta,ia=function(A,e){var t=A.createElement("iframe");return t.className="html2canvas-container",t.style.visibility="hidden",t.style.position="fixed",t.style.left="-10000px",t.style.top="0px",t.style.border="0",t.width=e.width.toString(),t.height=e.height.toString(),t.scrolling="no",t.setAttribute(Aa,"true"),A.body.appendChild(t),t},na=function(A){return new Promise((function(e){A.complete?e():A.src?(A.onload=e,A.onerror=e):e()}))},aa=function(A){return Promise.all([].slice.call(A.images,0).map(na))},sa=function(A){return new Promise((function(e,t){var i=A.contentWindow;if(!i)return t("No window assigned for iframe");var n=i.document;i.onload=A.onload=function(){i.onload=A.onload=null;var t=setInterval((function(){n.body.childNodes.length>0&&"complete"===n.readyState&&(clearInterval(t),e(A))}),50)}}))},ra=["all","d","content"],oa=function(A,e){for(var t=A.length-1;t>=0;t--){var i=A.item(t);-1===ra.indexOf(i)&&e.style.setProperty(i,A.getPropertyValue(i))}return e},la=function(A){var e="";return A&&(e+=""),e},ca=function(A,e,t){A&&A.defaultView&&(e!==A.defaultView.pageXOffset||t!==A.defaultView.pageYOffset)&&A.defaultView.scrollTo(e,t)},da=function(A){var e=A[0],t=A[1],i=A[2];e.scrollLeft=t,e.scrollTop=i},ha="___html2canvas___pseudoelement_before",ga="___html2canvas___pseudoelement_after",ua='{\n content: "" !important;\n display: none !important;\n}',wa=function(A){pa(A,"."+ha+":before"+ua+"\n ."+ga+":after"+ua)},pa=function(A,e){var t=A.ownerDocument;if(t){var i=t.createElement("style");i.textContent=e,A.appendChild(i)}},Ba=function(){function A(){}return A.getOrigin=function(e){var t=A._link;return t?(t.href=e,t.href=t.href,t.protocol+t.hostname+t.port):"about:blank"},A.isSameOrigin=function(e){return A.getOrigin(e)===A._origin},A.setContext=function(e){A._link=e.document.createElement("a"),A._origin=A.getOrigin(e.location.href)},A._origin="about:blank",A}(),ma=function(){function A(A,e){this.context=A,this._options=e,this._cache={}}return A.prototype.addImage=function(A){var e=Promise.resolve();return this.has(A)?e:Qa(A)||Fa(A)?((this._cache[A]=this.loadImage(A)).catch((function(){})),e):e},A.prototype.match=function(A){return this._cache[A]},A.prototype.loadImage=function(A){return i(this,void 0,void 0,(function(){var e,t,i,a,s=this;return n(this,(function(n){switch(n.label){case 0:return e=Ba.isSameOrigin(A),t=!va(A)&&!0===this._options.useCORS&&Ki.SUPPORT_CORS_IMAGES&&!e,i=!va(A)&&!e&&!Qa(A)&&"string"==typeof this._options.proxy&&Ki.SUPPORT_CORS_XHR&&!t,e||!1!==this._options.allowTaint||va(A)||Qa(A)||i||t?(a=A,i?[4,this.proxy(a)]:[3,2]):[2];case 1:a=n.sent(),n.label=2;case 2:return this.context.logger.debug("Added image "+A.substring(0,256)),[4,new Promise((function(A,e){var i=new Image;i.onload=function(){return A(i)},i.onerror=e,(ya(a)||t)&&(i.crossOrigin="anonymous"),i.src=a,!0===i.complete&&setTimeout((function(){return A(i)}),500),s._options.imageTimeout>0&&setTimeout((function(){return e("Timed out ("+s._options.imageTimeout+"ms) loading image")}),s._options.imageTimeout)}))];case 3:return[2,n.sent()]}}))}))},A.prototype.has=function(A){return void 0!==this._cache[A]},A.prototype.keys=function(){return Promise.resolve(Object.keys(this._cache))},A.prototype.proxy=function(A){var e=this,t=this._options.proxy;if(!t)throw new Error("No proxy defined");var i=A.substring(0,256);return new Promise((function(n,a){var s=Ki.SUPPORT_RESPONSE_TYPE?"blob":"text",r=new XMLHttpRequest;r.onload=function(){if(200===r.status)if("text"===s)n(r.response);else{var A=new FileReader;A.addEventListener("load",(function(){return n(A.result)}),!1),A.addEventListener("error",(function(A){return a(A)}),!1),A.readAsDataURL(r.response)}else a("Failed to proxy resource "+i+" with status code "+r.status)},r.onerror=a;var o=t.indexOf("?")>-1?"&":"?";if(r.open("GET",""+t+o+"url="+encodeURIComponent(A)+"&responseType="+s),"text"!==s&&r instanceof XMLHttpRequest&&(r.responseType=s),e._options.imageTimeout){var l=e._options.imageTimeout;r.timeout=l,r.ontimeout=function(){return a("Timed out ("+l+"ms) proxying "+i)}}r.send()}))},A}(),fa=/^data:image\/svg\+xml/i,Ea=/^data:image\/.*;base64,/i,Ca=/^data:image\/.*/i,Fa=function(A){return Ki.SUPPORT_SVG_DRAWING||!ba(A)},va=function(A){return Ca.test(A)},ya=function(A){return Ea.test(A)},Qa=function(A){return"blob"===A.substr(0,4)},ba=function(A){return"svg"===A.substr(-3).toLowerCase()||fa.test(A)},Ua=function(){function A(A,e){this.type=0,this.x=A,this.y=e}return A.prototype.add=function(e,t){return new A(this.x+e,this.y+t)},A}(),xa=function(A,e,t){return new Ua(A.x+(e.x-A.x)*t,A.y+(e.y-A.y)*t)},Ia=function(){function A(A,e,t,i){this.type=1,this.start=A,this.startControl=e,this.endControl=t,this.end=i}return A.prototype.subdivide=function(e,t){var i=xa(this.start,this.startControl,e),n=xa(this.startControl,this.endControl,e),a=xa(this.endControl,this.end,e),s=xa(i,n,e),r=xa(n,a,e),o=xa(s,r,e);return t?new A(this.start,i,s,o):new A(o,r,a,this.end)},A.prototype.add=function(e,t){return new A(this.start.add(e,t),this.startControl.add(e,t),this.endControl.add(e,t),this.end.add(e,t))},A.prototype.reverse=function(){return new A(this.end,this.endControl,this.startControl,this.start)},A}(),Sa=function(A){return 1===A.type},Ta=function(A){var e=A.styles,t=A.bounds,i=_A(e.borderTopLeftRadius,t.width,t.height),n=i[0],a=i[1],s=_A(e.borderTopRightRadius,t.width,t.height),r=s[0],o=s[1],l=_A(e.borderBottomRightRadius,t.width,t.height),c=l[0],d=l[1],h=_A(e.borderBottomLeftRadius,t.width,t.height),g=h[0],u=h[1],w=[];w.push((n+r)/t.width),w.push((g+c)/t.width),w.push((a+u)/t.height),w.push((o+d)/t.height);var p=Math.max.apply(Math,w);p>1&&(n/=p,a/=p,r/=p,o/=p,c/=p,d/=p,g/=p,u/=p);var B=t.width-r,m=t.height-d,f=t.width-c,E=t.height-u,C=e.borderTopWidth,F=e.borderRightWidth,v=e.borderBottomWidth,y=e.borderLeftWidth,Q=$A(e.paddingTop,A.bounds.width),b=$A(e.paddingRight,A.bounds.width),U=$A(e.paddingBottom,A.bounds.width),x=$A(e.paddingLeft,A.bounds.width);this.topLeftBorderDoubleOuterBox=n>0||a>0?La(t.left+y/3,t.top+C/3,n-y/3,a-C/3,ta.TOP_LEFT):new Ua(t.left+y/3,t.top+C/3),this.topRightBorderDoubleOuterBox=n>0||a>0?La(t.left+B,t.top+C/3,r-F/3,o-C/3,ta.TOP_RIGHT):new Ua(t.left+t.width-F/3,t.top+C/3),this.bottomRightBorderDoubleOuterBox=c>0||d>0?La(t.left+f,t.top+m,c-F/3,d-v/3,ta.BOTTOM_RIGHT):new Ua(t.left+t.width-F/3,t.top+t.height-v/3),this.bottomLeftBorderDoubleOuterBox=g>0||u>0?La(t.left+y/3,t.top+E,g-y/3,u-v/3,ta.BOTTOM_LEFT):new Ua(t.left+y/3,t.top+t.height-v/3),this.topLeftBorderDoubleInnerBox=n>0||a>0?La(t.left+2*y/3,t.top+2*C/3,n-2*y/3,a-2*C/3,ta.TOP_LEFT):new Ua(t.left+2*y/3,t.top+2*C/3),this.topRightBorderDoubleInnerBox=n>0||a>0?La(t.left+B,t.top+2*C/3,r-2*F/3,o-2*C/3,ta.TOP_RIGHT):new Ua(t.left+t.width-2*F/3,t.top+2*C/3),this.bottomRightBorderDoubleInnerBox=c>0||d>0?La(t.left+f,t.top+m,c-2*F/3,d-2*v/3,ta.BOTTOM_RIGHT):new Ua(t.left+t.width-2*F/3,t.top+t.height-2*v/3),this.bottomLeftBorderDoubleInnerBox=g>0||u>0?La(t.left+2*y/3,t.top+E,g-2*y/3,u-2*v/3,ta.BOTTOM_LEFT):new Ua(t.left+2*y/3,t.top+t.height-2*v/3),this.topLeftBorderStroke=n>0||a>0?La(t.left+y/2,t.top+C/2,n-y/2,a-C/2,ta.TOP_LEFT):new Ua(t.left+y/2,t.top+C/2),this.topRightBorderStroke=n>0||a>0?La(t.left+B,t.top+C/2,r-F/2,o-C/2,ta.TOP_RIGHT):new Ua(t.left+t.width-F/2,t.top+C/2),this.bottomRightBorderStroke=c>0||d>0?La(t.left+f,t.top+m,c-F/2,d-v/2,ta.BOTTOM_RIGHT):new Ua(t.left+t.width-F/2,t.top+t.height-v/2),this.bottomLeftBorderStroke=g>0||u>0?La(t.left+y/2,t.top+E,g-y/2,u-v/2,ta.BOTTOM_LEFT):new Ua(t.left+y/2,t.top+t.height-v/2),this.topLeftBorderBox=n>0||a>0?La(t.left,t.top,n,a,ta.TOP_LEFT):new Ua(t.left,t.top),this.topRightBorderBox=r>0||o>0?La(t.left+B,t.top,r,o,ta.TOP_RIGHT):new Ua(t.left+t.width,t.top),this.bottomRightBorderBox=c>0||d>0?La(t.left+f,t.top+m,c,d,ta.BOTTOM_RIGHT):new Ua(t.left+t.width,t.top+t.height),this.bottomLeftBorderBox=g>0||u>0?La(t.left,t.top+E,g,u,ta.BOTTOM_LEFT):new Ua(t.left,t.top+t.height),this.topLeftPaddingBox=n>0||a>0?La(t.left+y,t.top+C,Math.max(0,n-y),Math.max(0,a-C),ta.TOP_LEFT):new Ua(t.left+y,t.top+C),this.topRightPaddingBox=r>0||o>0?La(t.left+Math.min(B,t.width-F),t.top+C,B>t.width+F?0:Math.max(0,r-F),Math.max(0,o-C),ta.TOP_RIGHT):new Ua(t.left+t.width-F,t.top+C),this.bottomRightPaddingBox=c>0||d>0?La(t.left+Math.min(f,t.width-y),t.top+Math.min(m,t.height-v),Math.max(0,c-F),Math.max(0,d-v),ta.BOTTOM_RIGHT):new Ua(t.left+t.width-F,t.top+t.height-v),this.bottomLeftPaddingBox=g>0||u>0?La(t.left+y,t.top+Math.min(E,t.height-v),Math.max(0,g-y),Math.max(0,u-v),ta.BOTTOM_LEFT):new Ua(t.left+y,t.top+t.height-v),this.topLeftContentBox=n>0||a>0?La(t.left+y+x,t.top+C+Q,Math.max(0,n-(y+x)),Math.max(0,a-(C+Q)),ta.TOP_LEFT):new Ua(t.left+y+x,t.top+C+Q),this.topRightContentBox=r>0||o>0?La(t.left+Math.min(B,t.width+y+x),t.top+C+Q,B>t.width+y+x?0:r-y+x,o-(C+Q),ta.TOP_RIGHT):new Ua(t.left+t.width-(F+b),t.top+C+Q),this.bottomRightContentBox=c>0||d>0?La(t.left+Math.min(f,t.width-(y+x)),t.top+Math.min(m,t.height+C+Q),Math.max(0,c-(F+b)),d-(v+U),ta.BOTTOM_RIGHT):new Ua(t.left+t.width-(F+b),t.top+t.height-(v+U)),this.bottomLeftContentBox=g>0||u>0?La(t.left+y+x,t.top+E,Math.max(0,g-(y+x)),u-(v+U),ta.BOTTOM_LEFT):new Ua(t.left+y+x,t.top+t.height-(v+U))};!function(A){A[A.TOP_LEFT=0]="TOP_LEFT",A[A.TOP_RIGHT=1]="TOP_RIGHT",A[A.BOTTOM_RIGHT=2]="BOTTOM_RIGHT",A[A.BOTTOM_LEFT=3]="BOTTOM_LEFT"}(ta||(ta={}));var La=function(A,e,t,i,n){var a=(Math.sqrt(2)-1)/3*4,s=t*a,r=i*a,o=A+t,l=e+i;switch(n){case ta.TOP_LEFT:return new Ia(new Ua(A,l),new Ua(A,l-r),new Ua(o-s,e),new Ua(o,e));case ta.TOP_RIGHT:return new Ia(new Ua(A,e),new Ua(A+s,e),new Ua(o,l-r),new Ua(o,l));case ta.BOTTOM_RIGHT:return new Ia(new Ua(o,e),new Ua(o,e+r),new Ua(A+s,l),new Ua(A,l));case ta.BOTTOM_LEFT:default:return new Ia(new Ua(o,l),new Ua(o-s,l),new Ua(A,e+r),new Ua(A,e))}},Ma=function(A){return[A.topLeftBorderBox,A.topRightBorderBox,A.bottomRightBorderBox,A.bottomLeftBorderBox]},Ha=function(A){return[A.topLeftPaddingBox,A.topRightPaddingBox,A.bottomRightPaddingBox,A.bottomLeftPaddingBox]},Da=function(A,e,t){this.offsetX=A,this.offsetY=e,this.matrix=t,this.type=0,this.target=6},ka=function(A,e){this.path=A,this.target=e,this.type=1},Na=function(A){this.opacity=A,this.type=2,this.target=6},Oa=function(A){return 1===A.type},Ra=function(A,e){return A.length===e.length&&A.some((function(A,t){return A===e[t]}))},Pa=function(A){this.element=A,this.inlineLevel=[],this.nonInlineLevel=[],this.negativeZIndex=[],this.zeroOrAutoZIndexOrTransformedOrOpacity=[],this.positiveZIndex=[],this.nonPositionedFloats=[],this.nonPositionedInlineLevel=[]},Va=function(){function A(A,e){if(this.container=A,this.parent=e,this.effects=[],this.curves=new Ta(this.container),this.container.styles.opacity<1&&this.effects.push(new Na(this.container.styles.opacity)),null!==this.container.styles.transform){var t=this.container.bounds.left+this.container.styles.transformOrigin[0].number,i=this.container.bounds.top+this.container.styles.transformOrigin[1].number,n=this.container.styles.transform;this.effects.push(new Da(t,i,n))}if(0!==this.container.styles.overflowX){var a=Ma(this.curves),s=Ha(this.curves);Ra(a,s)?this.effects.push(new ka(a,6)):(this.effects.push(new ka(a,2)),this.effects.push(new ka(s,4)))}}return A.prototype.getEffects=function(A){for(var e=-1===[2,3].indexOf(this.container.styles.position),t=this.parent,i=this.effects.slice(0);t;){var n=t.effects.filter((function(A){return!Oa(A)}));if(e||0!==t.container.styles.position||!t.parent){if(i.unshift.apply(i,n),e=-1===[2,3].indexOf(t.container.styles.position),0!==t.container.styles.overflowX){var a=Ma(t.curves),s=Ha(t.curves);Ra(a,s)||i.unshift(new ka(s,6))}}else i.unshift.apply(i,n);t=t.parent}return i.filter((function(e){return ii(e.target,A)}))},A}(),Ka=function(A,e,t,i){A.container.elements.forEach((function(n){var a=ii(n.flags,4),s=ii(n.flags,2),r=new Va(n,A);ii(n.styles.display,2048)&&i.push(r);var o=ii(n.flags,8)?[]:i;if(a||s){var l=a||n.styles.isPositioned()?t:e,c=new Pa(r);if(n.styles.isPositioned()||n.styles.opacity<1||n.styles.isTransformed()){var d=n.styles.zIndex.order;if(d<0){var h=0;l.negativeZIndex.some((function(A,e){return d>A.element.container.styles.zIndex.order?(h=e,!1):h>0})),l.negativeZIndex.splice(h,0,c)}else if(d>0){var g=0;l.positiveZIndex.some((function(A,e){return d>=A.element.container.styles.zIndex.order?(g=e+1,!1):g>0})),l.positiveZIndex.splice(g,0,c)}else l.zeroOrAutoZIndexOrTransformedOrOpacity.push(c)}else n.styles.isFloating()?l.nonPositionedFloats.push(c):l.nonPositionedInlineLevel.push(c);Ka(r,c,a?c:t,o)}else n.styles.isInlineLevel()?e.inlineLevel.push(r):e.nonInlineLevel.push(r),Ka(r,e,t,o);ii(n.flags,8)&&Ga(n,o)}))},Ga=function(A,e){for(var t=A instanceof an?A.start:1,i=A instanceof an&&A.reversed,n=0;n0&&A.intrinsicHeight>0){var i=Ja(A),n=Ha(e);this.path(n),this.ctx.save(),this.ctx.clip(),this.ctx.drawImage(t,0,0,A.intrinsicWidth,A.intrinsicHeight,i.left,i.top,i.width,i.height),this.ctx.restore()}},t.prototype.renderNodeContent=function(A){return i(this,void 0,void 0,(function(){var e,i,a,r,o,l,c,d,h,g,u,w,p,B,m,f,E,C;return n(this,(function(n){switch(n.label){case 0:this.applyEffects(A.getEffects(4)),e=A.container,i=A.curves,a=e.styles,r=0,o=e.textNodes,n.label=1;case 1:return r0&&y>0&&(m=i.ctx.createPattern(w,"repeat"),i.renderRepeat(E,m,b,U))):function(A){return 2===A.type}(t)&&(f=ja(A,e,[null,null,null]),E=f[0],C=f[1],F=f[2],v=f[3],y=f[4],Q=0===t.position.length?[ZA]:t.position,b=$A(Q[0],v),U=$A(Q[Q.length-1],y),x=function(A,e,t,i,n){var a=0,s=0;switch(A.size){case 0:0===A.shape?a=s=Math.min(Math.abs(e),Math.abs(e-i),Math.abs(t),Math.abs(t-n)):1===A.shape&&(a=Math.min(Math.abs(e),Math.abs(e-i)),s=Math.min(Math.abs(t),Math.abs(t-n)));break;case 2:if(0===A.shape)a=s=Math.min(Fe(e,t),Fe(e,t-n),Fe(e-i,t),Fe(e-i,t-n));else if(1===A.shape){var r=Math.min(Math.abs(t),Math.abs(t-n))/Math.min(Math.abs(e),Math.abs(e-i)),o=ve(i,n,e,t,!0),l=o[0],c=o[1];s=r*(a=Fe(l-e,(c-t)/r))}break;case 1:0===A.shape?a=s=Math.max(Math.abs(e),Math.abs(e-i),Math.abs(t),Math.abs(t-n)):1===A.shape&&(a=Math.max(Math.abs(e),Math.abs(e-i)),s=Math.max(Math.abs(t),Math.abs(t-n)));break;case 3:if(0===A.shape)a=s=Math.max(Fe(e,t),Fe(e,t-n),Fe(e-i,t),Fe(e-i,t-n));else if(1===A.shape){r=Math.max(Math.abs(t),Math.abs(t-n))/Math.max(Math.abs(e),Math.abs(e-i));var d=ve(i,n,e,t,!1);l=d[0],c=d[1],s=r*(a=Fe(l-e,(c-t)/r))}}return Array.isArray(A.size)&&(a=$A(A.size[0],i),s=2===A.size.length?$A(A.size[1],n):a),[a,s]}(t,b,U,v,y),I=x[0],S=x[1],I>0&&S>0&&(T=i.ctx.createRadialGradient(C+b,F+U,0,C+b,F+U,I),Ee(t.stops,2*I).forEach((function(A){return T.addColorStop(A.stop,oe(A.color))})),i.path(E),i.ctx.fillStyle=T,I!==S?(L=A.bounds.left+.5*A.bounds.width,M=A.bounds.top+.5*A.bounds.height,D=1/(H=S/I),i.ctx.save(),i.ctx.translate(L,M),i.ctx.transform(1,0,0,H,0,0),i.ctx.translate(-L,-M),i.ctx.fillRect(C,D*(F-M)+M,v,y*D),i.ctx.restore()):i.ctx.fill())),n.label=6;case 6:return e--,[2]}}))},i=this,a=0,s=A.styles.backgroundImage.slice(0).reverse(),o.label=1;case 1:return a0?2!==l.style?[3,5]:[4,this.renderDashedDottedBorder(l.color,l.width,s,A.curves,2)]:[3,11]:[3,13];case 4:return n.sent(),[3,11];case 5:return 3!==l.style?[3,7]:[4,this.renderDashedDottedBorder(l.color,l.width,s,A.curves,3)];case 6:return n.sent(),[3,11];case 7:return 4!==l.style?[3,9]:[4,this.renderDoubleBorder(l.color,l.width,s,A.curves)];case 8:return n.sent(),[3,11];case 9:return[4,this.renderSolidBorder(l.color,s,A.curves)];case 10:n.sent(),n.label=11;case 11:s++,n.label=12;case 12:return r++,[3,3];case 13:return[2]}}))}))},t.prototype.renderDashedDottedBorder=function(A,e,t,a,s){return i(this,void 0,void 0,(function(){var i,r,o,l,c,d,h,g,u,w,p,B,m,f,E,C;return n(this,(function(n){return this.ctx.save(),i=function(A,e){switch(e){case 0:return Xa(A.topLeftBorderStroke,A.topRightBorderStroke);case 1:return Xa(A.topRightBorderStroke,A.bottomRightBorderStroke);case 2:return Xa(A.bottomRightBorderStroke,A.bottomLeftBorderStroke);default:return Xa(A.bottomLeftBorderStroke,A.topLeftBorderStroke)}}(a,t),r=Wa(a,t),2===s&&(this.path(r),this.ctx.clip()),Sa(r[0])?(o=r[0].start.x,l=r[0].start.y):(o=r[0].x,l=r[0].y),Sa(r[1])?(c=r[1].end.x,d=r[1].end.y):(c=r[1].x,d=r[1].y),h=0===t||2===t?Math.abs(o-c):Math.abs(l-d),this.ctx.beginPath(),3===s?this.formatPath(i):this.formatPath(r.slice(0,2)),g=e<3?3*e:2*e,u=e<3?2*e:e,3===s&&(g=e,u=e),w=!0,h<=2*g?w=!1:h<=2*g+u?(g*=p=h/(2*g+u),u*=p):(B=Math.floor((h+u)/(g+u)),m=(h-B*g)/(B-1),u=(f=(h-(B+1)*g)/B)<=0||Math.abs(u-m){const a=await tex2dataURL(A,n);if(a){const A=[];A.push({mimeType:a.mimeType,id:e,dataURL:a.dataURL,created:a.created,size:a.size,hasSVGwithBitmap:!1}),i(A,t)}};async function tex2dataURL(A,e){let t=0;for(;!e.mathjax&&!e.mathjaxLoaderFinished&&t<10;)await sleep$1(100),t++;e.mathjaxLoaderFinished||errorlog({where:"text2dataURL",fn:tex2dataURL,message:"mathjaxLoader not ready, using fallback. Try reloading Obsidian or restarting the Excalidraw plugin"});try{return await mathjaxSVG(A,e)}catch(t){await sleep$1(100);try{return await mathjaxSVG(A,e)}catch(t){await sleep$1(100);try{return await mathjaxSVG(A,e)}catch(t){return e.mathjax?new obsidian.Notice("Unknown error loading LaTeX. Using fallback solution. Try closing and reopening this drawing."):new obsidian.Notice("LaTeX support did not load. Using fallback solution. Try checking your network connection."),await mathjaxImage2html(A)}}}}async function mathjaxSVG(A,e){const t=e.mathjax.tex2svg(A,{display:!0,scale:4}).querySelector("svg");if(t){const A=svgToBase64(t.outerHTML);return{mimeType:"image/svg+xml",fileId:fileid(),dataURL:A,created:Date.now(),size:await getImageSize(A)}}return null}async function mathjaxImage2html(A){const e=document.body.createDiv();e.style.display="table";const t=window.MathJax.tex2chtml(A,{display:!0,scale:4});t.style.margin="3px",t.style.color="black";const i=t.querySelector("mjx-assistive-mml");i&&i.parentElement.removeChild(i),e.appendChild(t),window.MathJax.typeset();const n=await html2canvas(e,{backgroundColor:null});return document.body.removeChild(e),{mimeType:"image/png",fileId:fileid(),dataURL:n.toDataURL(),created:Date.now(),size:{height:n.height,width:n.width}}}const THEME_FILTER="invert(100%) hue-rotate(180deg) saturate(1.25)";class EmbeddedFile{constructor(A,e,t){this.file=null,this.isSVGwithBitmap=!1,this.img="",this.imgInverted="",this.mtime=0,this.mimeType="application/octet-stream",this.size={height:0,width:0},this.attemptCounter=0,this.plugin=A,this.resetImage(e,t)}resetImage(A,e){this.imgInverted=this.img="",this.mtime=0,this.linkParts=getLinkParts(e),this.hostPath=A,this.linkParts.path?(this.linkParts.width||(this.linkParts.width=this.plugin.settings.mdSVGwidth),this.linkParts.height||(this.linkParts.height=this.plugin.settings.mdSVGmaxHeight),this.file=this.plugin.app.metadataCache.getFirstLinkpathDest(this.linkParts.path,A),this.file||0==this.attemptCounter++&&new obsidian.Notice(`Excalidraw Warning: could not find image file: ${e}`,5e3)):new obsidian.Notice(`Excalidraw Error\nIncorrect embedded filename: ${e}`)}fileChanged(){return this.file||(this.file=this.plugin.app.metadataCache.getFirstLinkpathDest(this.linkParts.path,this.hostPath),this.file)?this.mtime!=this.file.stat.mtime:(this.attemptCounter++,!1)}setImage(A,e,t,i,n){if(this.file){switch(this.fileChanged()&&(this.imgInverted=this.img=""),this.mtime=this.file.stat.mtime,this.size=t,this.mimeType=e,i&&n){case!0:this.imgInverted=A;break;case!1:this.img=A}this.isSVGwithBitmap=n}}isLoaded(A){return this.file||(this.file=this.plugin.app.metadataCache.getFirstLinkpathDest(this.linkParts.path,this.hostPath),this.file)?!this.fileChanged()&&(this.isSVGwithBitmap&&A?""!==this.imgInverted:""!==this.img):(this.attemptCounter++,!0)}getImage(A){return this.file?A&&this.isSVGwithBitmap?this.imgInverted:this.img:""}}class EmbeddedFilesLoader{constructor(A,e){this.terminate=!1,this.plugin=A,this.isDark=e,this.uid=nanoid()}async getObsidianImage(A,e){if(!this.plugin||!A)return null;const t=A instanceof EmbeddedFile?A.file:A,i=A instanceof EmbeddedFile?A.linkParts:{original:t.path,path:t.path,isBlockRef:!1,ref:null,width:this.plugin.settings.mdSVGwidth,height:this.plugin.settings.mdSVGmaxHeight};let n=!1;const a=this.plugin.app,s=this.plugin.isExcalidrawFile(t);if(!IMAGE_TYPES.contains(t.extension)&&!s&&"md"!==t.extension)return null;const r=await a.vault.readBinary(t),o=s?await(async A=>{const i=hasExportTheme(this.plugin,t)?getExportTheme(this.plugin,t,"light"):void 0,a={withBackground:!!hasExportBackground(this.plugin,t)&&getWithBackground(this.plugin,t),withTheme:!!i},s=await createSVG(t.path,!0,a,this,i,null,null,[],this.plugin,e+1,getSVGPadding(this.plugin,t)),r=s.querySelectorAll("image:not([href^='data:image/svg'])");return r.length>0&&(n=!0),n&&A&&r.forEach((A=>{var e;const t=null===(e=A.parentElement)||void 0===e?void 0:e.id;s.querySelectorAll(`use[href='#${t}']`).forEach((A=>{A.setAttribute("filter",THEME_FILTER)}))})),!n&&s.getAttribute("hasbitmap")&&(n=!0),svgToBase64(s.outerHTML)})(this.isDark):null;let l="image/svg+xml";if(!s)switch(t.extension){case"png":l="image/png";break;case"jpeg":case"jpg":l="image/jpeg";break;case"gif":l="image/gif";break;case"svg":case"md":l="image/svg+xml";break;default:l="application/octet-stream"}let c=null!=o?o:"svg"===t.extension?await getSVGData(a,t):"md"===t.extension?null:await getDataURL(r,l);if(!c){const A=await this.convertMarkdownToSVG(this.plugin,t,i);c=A.dataURL,n=A.hasSVGwithBitmap}const d=await getImageSize(c);return{mimeType:l,fileId:await generateIdFromFile(r),dataURL:c,created:t.stat.mtime,hasSVGwithBitmap:n,size:d}}async loadSceneFiles(A,e,i){var n,a;if(i>4)return void new obsidian.Notice(t("INFINITE_LOOP_WARNING")+i.toString(),6e3);const s=A.getFileEntries();let r;void 0===this.isDark&&(this.isDark="dark"===(null===(a=null===(n=null==A?void 0:A.scene)||void 0===n?void 0:n.appState)||void 0===a?void 0:a.theme));const o=[];for(;!this.terminate&&!(r=s.next()).done;){const A=r.value[1];if(A.isLoaded(this.isDark))A.isSVGwithBitmap&&o.push({mimeType:A.mimeType,id:r.value[0],dataURL:A.getImage(this.isDark),created:A.mtime,size:A.size,hasSVGwithBitmap:A.isSVGwithBitmap});else{const e=await this.getObsidianImage(A,i);e&&o.push({mimeType:e.mimeType,id:r.value[0],dataURL:e.dataURL,created:e.created,size:e.size,hasSVGwithBitmap:e.hasSVGwithBitmap})}}let l;const c=A.getEquationEntries();for(;!this.terminate&&!(l=c.next()).done;)if(!A.getEquation(l.value[0]).isLoaded){const A=l.value[1].latex,e=await tex2dataURL(A,this.plugin);e&&o.push({mimeType:e.mimeType,id:l.value[0],dataURL:e.dataURL,created:e.created,size:e.size,hasSVGwithBitmap:!1})}if(!this.terminate)try{e(o,this.isDark)}catch(A){errorlog({where:"EmbeddedFileLoader.loadSceneFiles",error:A})}}async convertMarkdownToSVG(A,e,t){var i,n,a,s;let r=!1;const o=await getTransclusion(t,A.app,e);let l=(null!==(i=o.leadingHashes)&&void 0!==i?i:"")+o.contents;""===l&&(l="# Empty markdown file\nCTRL+Click here to open the file for editing in the current active pane, or CTRL+SHIFT+Click to open it in an adjacent pane.");const c=A.app.metadataCache.getFileCache(e);let d,h=A.settings.mdFont;switch((null==c?void 0:c.frontmatter)&&null!=c.frontmatter["excalidraw-font"]&&(h=c.frontmatter["excalidraw-font"]),h){case"Virgil":d=VIRGIL_FONT;break;case"Cascadia":d=CASCADIA_FONT;break;case"":d="";break;default:const t=await getFontDataURL(A.app,h,e.path);d=t.fontDef,h=t.fontName}const g=(null==c?void 0:c.frontmatter)&&null!==(n=c.frontmatter["excalidraw-font-color"])&&void 0!==n?n:A.settings.mdFontColor;let u=(null==c?void 0:c.frontmatter)&&null!==(a=c.frontmatter["excalidraw-css"])&&void 0!==a?a:"",w=!1;if(u&&""!=u){const t=A.app.metadataCache.getFirstLinkpathDest(u,e.path);t&&(u=await A.app.vault.read(t),w=!0)}if(!w)if(A.settings.mdCSS&&""!==A.settings.mdCSS){const t=A.app.metadataCache.getFirstLinkpathDest(A.settings.mdCSS,e.path);u+=t?`\n${await A.app.vault.read(t)}`:DEFAULT_MD_EMBED_CSS}else u+=DEFAULT_MD_EMBED_CSS;const p=(null==c?void 0:c.frontmatter)&&null!==(s=c.frontmatter["excalidraw-border-color"])&&void 0!==s?s:A.settings.mdBorderColor;p&&""!==p&&!u.match(/svg/i)&&(u+=`svg{border:2px solid;color:${p};transform:scale(.95)}`);let B=` width="${t.width}px" height="100000"`,m=` width="${t.width}px" height="100%"`;const f=(A,e,t)=>`${t?``:""}${A}${e}${""!==d?``:""}`,E=createDiv();E.setAttribute("xmlns","http://www.w3.org/1999/xhtml"),E.setAttribute("class","excalidraw-md-host"),""!==h&&(E.style.fontFamily=h),E.style.overflow="auto",E.style.display="block",E.style.color=g&&""!==g?g:"initial",await obsidian.MarkdownRenderer.renderMarkdown(l,E,e.path,A),E.querySelectorAll(":scope > *[class^='frontmatter']").forEach((A=>E.removeChild(A)));const C=Array.from(E.querySelectorAll("span[class='internal-embed']"));for(let A=0;A{const e=A.style,t=window.getComputedStyle(A);let i="";for(const A in e)e.hasOwnProperty(A)&&(i+=`${A}: ${t[A]};`);A.setAttribute("style",i)}));const b=(new XMLSerializer).serializeToString(y),U=(new XMLSerializer).serializeToString(Q);document.body.removeChild(F);const x=new DOMParser,I=x.parseFromString(f(b,U),"image/svg+xml").firstElementChild,S=createDiv();S.appendChild(I),document.body.appendChild(S);const T=I.querySelector(".excalidraw-md-footer").scrollHeight,L=I.querySelector(".excalidraw-md-host").scrollHeight+T,M=L<=t.height?L:t.height;document.body.removeChild(S),B=` width="${t.width}px" height="${M}px"`,m=` width="${t.width}px" height="${M}px"`,E.style.height=M-T+"px",E.style.overflow="hidden";const H=E.querySelectorAll("img:not([src^='data:image/svg+xml'])");H.length>0&&(r=!0),r&&this.isDark&&H.forEach((A=>{A instanceof HTMLImageElement&&(A.style.filter=THEME_FILTER)}));const D=f((new XMLSerializer).serializeToString(E),'
',u);return A.ea.mostRecentMarkdownSVG=x.parseFromString(D,"image/svg+xml").firstElementChild,{dataURL:svgToBase64(D),hasSVGwithBitmap:r}}}const getSVGData=async(A,e)=>{const t=await A.vault.read(e);return svgToBase64(t)},generateIdFromFile=async A=>{let e;try{const t=await window.crypto.subtle.digest("SHA-1",A);e=Array.from(new Uint8Array(t)).map((A=>A.toString(16).padStart(2,"0"))).join("")}catch(A){errorlog({where:"EmbeddedFileLoader.generateIdFromFile",error:A}),e=fileid()}return e},REGEX_LINK={ +//![[link|alias]] [alias](link){num} +EXPR:/(!)?(\[\[([^|\]]+)\|?([^\]]+)?]]|\[([^\]]*)]\(([^)]*)\))(\{(\d+)\})?/g,getRes:A=>A.matchAll(REGEX_LINK.EXPR),isTransclusion:A=>!!A.value[1],getLink:A=>A.value[3]?A.value[3]:A.value[6],isWikiLink:A=>!!A.value[3],getAliasOrLink:A=>REGEX_LINK.isWikiLink(A)?A.value[4]?A.value[4]:A.value[3]:A.value[5]?A.value[5]:A.value[6],getWrapLength:(A,e)=>{const t=parseInt(A.value[8]);return isNaN(t)?e>0?e:null:t}},DRAWING_REG=/\n# Drawing\n[^`]*(```json\n)([\s\S]*?)```\n/gm,DRAWING_REG_FALLBACK=/\n# Drawing\n(```json\n)?(.*)(```)?(%%)?/gm,DRAWING_COMPRESSED_REG=/(\n# Drawing\n[^`]*(?:```compressed\-json\n))([\s\S]*?)(```\n)/gm,DRAWING_COMPRESSED_REG_FALLBACK=/(\n# Drawing\n(?:```compressed\-json\n)?)(.*)((```)?(%%)?)/gm,REG_LINKINDEX_HYPERLINK=/^\w+:\/\//,isCompressedMD=A=>null!==A.match(/```compressed\-json\n/gm),getDecompressedScene=A=>{let e,t=A.matchAll(DRAWING_COMPRESSED_REG);return e=t.next(),e.done&&(t=A.matchAll(DRAWING_COMPRESSED_REG_FALLBACK),e=t.next()),e.value&&e.value.length>1?[decompress(e.value[2]),e]:[null,e]},changeThemeOfExcalidrawMD=A=>{const e=isCompressedMD(A);let t=e?getDecompressedScene(A)[0]:A;return t?(isObsidianThemeDark?1===(t.match(/"theme"\s*:\s*"light"\s*,/g)||[]).length&&(t=t.replace(/"theme"\s*:\s*"light"\s*,/,'"theme": "dark",')):1===(t.match(/"theme"\s*:\s*"dark"\s*,/g)||[]).length&&(t=t.replace(/"theme"\s*:\s*"dark"\s*,/,'"theme": "light",')),e?A.replace(DRAWING_COMPRESSED_REG,`$1${compress(t)}$3`):t):A};function getJSON(A){let e,t;if(isCompressedMD(A)){const[e,t]=getDecompressedScene(A);return e?{scene:e.substring(0,e.lastIndexOf("}")+1),pos:t.value.index}:{scene:A,pos:t.value?t.value.index:0}}if(e=A.matchAll(DRAWING_REG),t=e.next(),t.done&&(e=A.matchAll(DRAWING_REG_FALLBACK),t=e.next()),t.value&&t.value.length>1){const A=t.value[2];return{scene:A.substr(0,A.lastIndexOf("}")+1),pos:t.value.index}}return{scene:A,pos:t.value?t.value.index:0}}function getMarkdownDrawingSection(A,e){return e?`%%\n# Drawing\n\`\`\`compressed-json\n${compress(A)}\n\`\`\`\n%%`:`%%\n# Drawing\n\`\`\`json\n${A}\n\`\`\`\n%%`}const estimateMaxLineLen=(A,e)=>{if(!e||!A)return null;if(A===e)return null;let t=0;const i=A.split("\n");if(1===i.length)return null;for(const A of i)A.length>t&&(t=A.length);return t},wrap=(A,e)=>e?wrapText(A,e,!1,0):A;class ExcalidrawData{constructor(A){this.plugin=A,this.textElements=null,this.elementLinks=null,this.scene=null,this.deletedElements=[],this.file=null,this.textMode=TextMode.raw,this.loaded=!1,this.files=null,this.equations=null,this.compatibilityMode=!1,this.selectedElementIds={},this.disableCompression=!1,this.app=A.app,this.files=new Map,this.equations=new Map}initializeNonInitializedFields(){var A,e;if(!this.scene||!this.scene.elements)return;const t=this.scene.elements;for(const i of t){if(i.boundElements){const A=new Map;i.boundElements.forEach((e=>{A.set(e.id,e.type)}));const e=Array.from(A,(([A,e])=>({id:A,type:e})));e.length!==i.boundElements.length&&(i.boundElements=e)}i.boundElementIds&&(i.boundElements||(i.boundElements=[]),i.boundElements=i.boundElements.concat(i.boundElementIds.map((A=>({type:"arrow",id:A})))),delete i.boundElementIds),"text"!==i.type||i.containerId||(i.containerId=null),null===i.x&&(i.x=0),null===i.y&&(i.y=0),null===(null===(A=i.startBinding)||void 0===A?void 0:A.focus)&&(i.startBinding.focus=0),null===(null===(e=i.endBinding)||void 0===e?void 0:e.focus)&&(i.endBinding.focus=0),null===i.fontSize&&(i.fontSize=20)}try{t.filter((A=>"text"===A.type&&A.containerId&&t.some((e=>e.id===A.containerId&&e.boundElements.length>0&&e.boundElements.some((e=>"text"===e.type&&e.id!==A.id&&e.id.length>8)))))).forEach((A=>{try{const e=t.filter((e=>e.id===A.containerId))[0],i=e.boundElements.filter((A=>!("text"===A.type&&!t.some((e=>e.id===A.id)))));e.boundElements=[{id:A.id,type:"text"}].concat(i)}catch(A){}})),t.filter((A=>A.boundElements&&A.boundElements.length>0)).forEach((A=>{const e=A.boundElements.filter((A=>t.some((e=>e.id===A.id))));e.length!==A.boundElements.length&&(A.boundElements=e)})),t.filter((A=>"text"===A.type&&A.containerId&&!t.some((e=>e.id===A.containerId)))).forEach((A=>{A.containerId=null}))}catch(A){}}async loadData(A,e,t){if(!e)return!1;if(this.loaded=!1,this.selectedElementIds={},this.textElements=new Map,this.elementLinks=new Map,this.file!=e&&(this.files.clear(),this.equations.clear()),this.file=e,this.compatibilityMode=!1,this.setShowLinkBrackets(),this.setLinkPrefix(),this.setUrlPrefix(),this.scene=null,this.plugin.settings.syncExcalidraw){const A=`${e.path.substring(0,e.path.lastIndexOf(".md"))}.excalidraw`,t=this.app.vault.getAbstractFileByPath(A);if(t&&t instanceof obsidian.TFile&&t.stat.mtime>e.stat.mtime){const A=await this.app.vault.read(t);this.scene=JSON.parse(A)}}let i=null;i=(()=>{const e=getJSON(A);if(-1===e.pos)throw new Error("Excalidraw JSON not found in the file");return this.scene||(this.scene=JSON_parse(e.scene)),e})(),this.deletedElements=this.scene.elements.filter((A=>A.isDeleted)),this.scene.elements=this.scene.elements.filter((A=>!A.isDeleted)),this.scene.files||(this.scene.files={}),hasExportTheme(this.plugin,this.file)?this.scene.appState.theme=getExportTheme(this.plugin,this.file,"light"):this.plugin.settings.matchThemeAlways&&(this.scene.appState.theme=isObsidianThemeDark()?"dark":"light"),this.initializeNonInitializedFields();let n=(A=A.substring(0,i.pos)).search(/(^%%\n)?# Text Elements\n/m);if(-1===n)return await this.setTextMode(t,!1),this.loaded=!0,!0;n+=A.match(/((^%%\n)?# Text Elements\n)/m)[0].length,A=A.substring(n),n=0;const a=" ^12345678\n\n".length;let s,r=A.matchAll(/\s\^(.{8})[\n]+/g);for(;!(s=r.next()).done;){const e=A.substring(n,s.value.index),t=s.value[1],i=this.scene.elements.filter((A=>A.id===t))[0];if(i)if("text"!==i.type)i.link!==e&&(i.link=e,i.version++,i.versionNonce++),this.elementLinks.set(t,e);else{const A=estimateMaxLineLen(i.text,i.originalText),n=await this.parse(e);this.textElements.set(t,{raw:e,parsed:n.parsed,wrapAt:A}),n.link&&(i.link=n.link),!i||i.rawText&&""!==i.rawText||(i.rawText=e)}n=s.value.index+a}for(r=(A=A.substring(A.indexOf("# Embedded files\n")+"# Embedded files\n".length)).matchAll(/([\w\d]*):\s*\[\[([^\]]*)]]\n/gm);!(s=r.next()).done;){const A=new EmbeddedFile(this.plugin,this.file.path,s.value[2]);this.setFile(s.value[1],A)}for(r=A.matchAll(/([\w\d]*):\s*\$\$(.*)(\$\$\s*\n)/gm);!(s=r.next()).done;)this.setEquation(s.value[1],{latex:s.value[2],isLoaded:!1});return this.findNewTextElementsInScene(),this.findNewElementLinksInScene(),await this.setTextMode(t,!0),this.loaded=!0,!0}async loadLegacyData(A,e){return!!e&&(this.loaded=!1,this.selectedElementIds={},this.compatibilityMode=!0,this.file=e,this.textElements=new Map,this.elementLinks=new Map,this.setShowLinkBrackets(),this.setLinkPrefix(),this.setUrlPrefix(),this.scene=JSON.parse(A),this.scene.files||(this.scene.files={}),this.initializeNonInitializedFields(),this.plugin.settings.matchThemeAlways&&(this.scene.appState.theme=isObsidianThemeDark()?"dark":"light"),this.files.clear(),this.equations.clear(),this.findNewTextElementsInScene(),this.findNewElementLinksInScene(),await this.setTextMode(TextMode.raw,!0),this.loaded=!0,!0)}async setTextMode(A,e=!1){this.textMode=A,await this.updateSceneTextElements(e)}updateTextElement(A,e,t,i=!1){if(i||e!=A.text){const i=_measureText(e,A.fontSize,A.fontFamily);A.text=e,A.originalText=t,A.containerId||(A.width=i.w),A.height=i.h,A.baseline=i.baseline}}async updateSceneTextElements(A=!1){var e,t,i,n;const a=null===(e=this.scene.elements)||void 0===e?void 0:e.filter((A=>"text"===A.type));for(const e of a){const a=null!==(i=null!==(t=await this.getText(e.id,!1))&&void 0!==t?t:e.originalText)&&void 0!==i?i:e.text,s=null===(n=this.textElements.get(e.id))||void 0===n?void 0:n.wrapAt;this.updateTextElement(e,wrap(a,s),a,A)}}async getText(A,e=!0){const t=this.textElements.get(A);return t?this.textMode===TextMode.parsed?(t.parsed||this.textElements.set(A,{raw:t.raw,parsed:(await this.parse(t.raw)).parsed,wrapAt:t.wrapAt}),e?wrap(t.parsed,t.wrapAt):t.parsed):t.raw:null}findNewElementLinksInScene(){var A;const e=null===(A=this.scene.elements)||void 0===A?void 0:A.filter((A=>"text"!==A.type&&A.link&&A.link.startsWith("[[")&&!this.elementLinks.has(A.id)));if(0===e.length)return!1;let t,i=JSON.stringify(this.scene);for(const A of e)t=A.id,A.id.length>8&&(t=nanoid(),i=i.replaceAll(A.id,t)),this.elementLinks.set(t,A.link);return this.scene=JSON.parse(i),!0}findNewTextElementsInScene(A={}){var e;this.selectedElementIds=A;const t=null===(e=this.scene.elements)||void 0===e?void 0:e.filter((A=>"text"===A.type));let i,n=JSON.stringify(this.scene),a=!1;for(const A of t)if(i=A.id,A.id.length>8){if(a=!0,i=nanoid(),this.selectedElementIds[A.id]&&(delete this.selectedElementIds[A.id],this.selectedElementIds[i]=!0),n=n.replaceAll(A.id,i),this.textElements.has(A.id)){const e=this.textElements.get(A.id);this.textElements.set(i,{raw:e.raw,parsed:e.parsed,wrapAt:e.wrapAt}),this.textElements.delete(A.id)}if(!this.textElements.has(i)){const e=A.rawText&&""!==A.rawText?A.rawText:A.text,t=estimateMaxLineLen(A.text,A.originalText);this.textElements.set(i,{raw:e,parsed:null,wrapAt:t}),this.parseasync(i,e,t)}}return a&&(this.scene=JSON.parse(n)),a}updateElementLinksFromScene(){var A;for(const e of this.elementLinks.keys()){const t=null===(A=this.scene.elements)||void 0===A?void 0:A.filter((A=>"text"!==A.type&&A.id===e&&A.link&&A.link.startsWith("[[")));0===t.length?this.elementLinks.delete(e):this.elementLinks.set(e,t[0].link)}}async updateTextElementsFromScene(){var A,e,t,i;for(const n of this.textElements.keys()){const a=null===(A=this.scene.elements)||void 0===A?void 0:A.filter((A=>"text"===A.type&&A.id===n));if(0===a.length)this.textElements.delete(n);else if(await this.getText(n,!1)!==(null!==(e=a[0].originalText)&&void 0!==e?e:a[0].text)){const A=estimateMaxLineLen(a[0].text,a[0].originalText);this.textElements.set(n,{raw:null!==(t=a[0].originalText)&&void 0!==t?t:a[0].text,parsed:(await this.parse(null!==(i=a[0].originalText)&&void 0!==i?i:a[0].text)).parsed,wrapAt:A})}}}async parseasync(A,e,t){this.textElements.set(A,{raw:e,parsed:(await this.parse(e)).parsed,wrapAt:t})}parseLinks(A,e,t){return A.substring(e,t.value.index)+(this.showLinkBrackets?"[[":"")+REGEX_LINK.getAliasOrLink(t)+(this.showLinkBrackets?"]]":"")}async getTransclusion(A){const e=getLinkParts(A,this.file),t=this.app.metadataCache.getFirstLinkpathDest(e.path,this.file.path);return await getTransclusion(e,this.app,t,this.plugin.settings.pageTransclusionCharLimit)}async parse(A){let e="",t=null,i=0;const n=REGEX_LINK.getRes(A);let a,s=!1,r=!1;for(A.match(REG_LINKINDEX_HYPERLINK)&&(t=A,r=!0);!(a=n.next()).done;){if(!t){const A=REGEX_LINK.getLink(a);t=A.match(REG_LINKINDEX_HYPERLINK)?A:`[[${A}]]`}if(REGEX_LINK.isTransclusion(a)){const t=(await this.getTransclusion(REGEX_LINK.getLink(a))).contents;e+=A.substring(i,a.value.index)+wrapText(t,REGEX_LINK.getWrapLength(a,this.plugin.settings.wordWrappingDefault),this.plugin.settings.forceWrap)}else{const t=this.parseLinks(A,i,a);t&&(e+=t,r||s||(REGEX_LINK.getLink(a).match(REG_LINKINDEX_HYPERLINK)?r=!0:s=!0))}i=a.value.index+a.value[0].length}return e+=A.substring(i,A.length),s&&(e=this.linkPrefix+e),r&&(e=this.urlPrefix+e),{parsed:e,link:t}}quickParse(A){if((A=>{const e=REGEX_LINK.getRes(A);let t;for(;!(t=e.next()).done;)if(REGEX_LINK.isTransclusion(t))return!0;return!1})(A))return[null,null];let e="",t=null,i=0;const n=REGEX_LINK.getRes(A);let a,s=!1,r=!1;for(A.match(REG_LINKINDEX_HYPERLINK)&&(t=A,r=!0);!(a=n.next()).done;){if(!t){const A=REGEX_LINK.getLink(a);t=A.match(REG_LINKINDEX_HYPERLINK)?A:`[[${A}]]`}const n=this.parseLinks(A,i,a);n&&(e+=n,r||s||(REGEX_LINK.getLink(a).match(REG_LINKINDEX_HYPERLINK)?r=!0:s=!0)),i=a.value.index+a.value[0].length}return e+=A.substring(i,A.length),s&&(e=this.linkPrefix+e),r&&(e=this.urlPrefix+e),[e,t]}generateMD(A=[]){let e="# Text Elements\n";for(const A of this.textElements.keys())e+=`${this.textElements.get(A).raw} ^${A}\n\n`;for(const A of this.elementLinks.keys())e+=`${this.elementLinks.get(A)} ^${A}\n\n`;if(e+=this.equations.size>0||this.files.size>0?"\n# Embedded files\n":"",this.equations.size>0)for(const A of this.equations.keys())e+=`${A}: $$${this.equations.get(A).latex}$$\n`;if(this.files.size>0)for(const A of this.files.keys())e+=`${A}: [[${this.files.get(A).linkParts.original}]]\n`;return e+=this.equations.size>0||this.files.size>0?"\n":"",e+getMarkdownDrawingSection(JSON.stringify({type:this.scene.type,version:this.scene.version,source:this.scene.source,elements:this.scene.elements.concat(A),appState:this.scene.appState,files:this.scene.files},null,"\t"),!this.disableCompression&&this.plugin.settings.compress)}async syncFiles(){var A;let e=!1;const t=this.scene,i=t.elements.filter((A=>"image"===A.type)).map((A=>A.fileId));if(this.files.forEach(((A,t)=>{i.contains(t)||(this.files.delete(t),e=!0)})),this.equations.forEach(((A,t)=>{i.contains(t)||(this.equations.delete(t),e=!0)})),!t.files||t.files=={})return!1;const n=new Set;i.forEach((A=>{if(n.has(A)){const i=this.getFile(A),a=this.getEquation(A);if(i&&("md"!==i.file.extension||this.plugin.isExcalidrawFile(i.file)))return;const s=fileid();t.elements.filter((e=>e.fileId===A))[0].fileId=s,e=!0,n.add(s),i&&this.setFile(s,new EmbeddedFile(this.plugin,this.file.path,i.linkParts.original)),a&&this.setEquation(s,{latex:a.latex,isLoaded:!1})}n.add(A)}));for(const i of Object.keys(t.files))if(!this.hasFile(i)&&!this.hasEquation(i)){e=!0;let n=`Pasted Image ${window.moment().format("YYYYMMDDHHmmss_SSS")}`;const a=t.files[i].mimeType;switch(a){case"image/png":default:n+=".png";break;case"image/jpeg":n+=".jpg";break;case"image/svg+xml":n+=".svg";break;case"image/gif":n+=".gif"}const s=(await getAttachmentsFolderAndFilePath(this.app,this.file.path,n)).filepath,r=t.files[i].dataURL;await this.app.vault.createBinary(s,getBinaryFileFromDataURL(r));const o=new EmbeddedFile(this.plugin,this.file.path,s);o.setImage(r,a,{height:0,width:0},"dark"===(null===(A=t.appState)||void 0===A?void 0:A.theme),"image/svg+xml"===a),this.setFile(i,o)}return e}async syncElements(A,e){this.scene=A;let t=!1;return this.compatibilityMode||(t=await this.syncFiles(),this.scene.files={}),this.updateElementLinksFromScene(),t=t||this.setLinkPrefix()||this.setUrlPrefix()||this.setShowLinkBrackets()||this.findNewElementLinksInScene(),await this.updateTextElementsFromScene(),t||this.findNewTextElementsInScene(e)}async updateScene(A){this.scene=JSON_parse(A),this.updateElementLinksFromScene();const e=this.setLinkPrefix()||this.setUrlPrefix()||this.setShowLinkBrackets()||this.findNewElementLinksInScene();return await this.updateTextElementsFromScene(),!(!e&&!this.findNewTextElementsInScene()||(await this.updateSceneTextElements(),0))}getRawText(A){var e;return null===(e=this.textElements.get(A))||void 0===e?void 0:e.raw}getParsedText(A){const e=this.textElements.get(A);return e?[wrap(e.parsed,e.wrapAt),e.parsed,null]:[null,null,null]}setTextElement(A,e,t,i){const n=estimateMaxLineLen(e,t),[a,s]=this.quickParse(t);return a?(this.textElements.set(A,{raw:t,parsed:a,wrapAt:n}),[wrap(a,n),a,s]):(this.parse(t).then((e=>{const a=e.parsed;this.textElements.set(A,{raw:t,parsed:a,wrapAt:n}),a&&i(wrap(a,n),a)})),[null,null,null])}async addTextElement(A,e,t){let i=estimateMaxLineLen(e,t);this.textElements.has(A)&&(i=this.textElements.get(A).wrapAt);const n=await this.parse(t);return this.textElements.set(A,{raw:t,parsed:n.parsed,wrapAt:i}),[wrap(n.parsed,i),n.parsed,n.link]}deleteTextElement(A){this.textElements.delete(A)}getOpenMode(){const A=this.app.metadataCache.getFileCache(this.file);let e=this.plugin.settings.defaultMode;switch((null==A?void 0:A.frontmatter)&&null!=A.frontmatter["excalidraw-default-mode"]&&(e=A.frontmatter["excalidraw-default-mode"]),e){case"zen":return{viewModeEnabled:!1,zenModeEnabled:!0};case"view":return{viewModeEnabled:!0,zenModeEnabled:!1};default:return{viewModeEnabled:!1,zenModeEnabled:!1}}}getLinkOpacity(){const A=this.app.metadataCache.getFileCache(this.file);let e=this.plugin.settings.linkOpacity;return(null==A?void 0:A.frontmatter)&&null!=A.frontmatter["excalidraw-linkbutton-opacity"]&&(e=A.frontmatter["excalidraw-linkbutton-opacity"]),e}getOnLoadScript(){const A=this.app.metadataCache.getFileCache(this.file);return(null==A?void 0:A.frontmatter)&&null!=A.frontmatter["excalidraw-onload-script"]?A.frontmatter["excalidraw-onload-script"]:null}setLinkPrefix(){const A=this.linkPrefix,e=this.app.metadataCache.getFileCache(this.file);return(null==e?void 0:e.frontmatter)&&null!=e.frontmatter["excalidraw-link-prefix"]?this.linkPrefix=e.frontmatter["excalidraw-link-prefix"]:this.linkPrefix=this.plugin.settings.linkPrefix,A!=this.linkPrefix}setUrlPrefix(){const A=this.urlPrefix,e=this.app.metadataCache.getFileCache(this.file);return(null==e?void 0:e.frontmatter)&&null!=e.frontmatter["excalidraw-url-prefix"]?this.urlPrefix=e.frontmatter["excalidraw-url-prefix"]:this.urlPrefix=this.plugin.settings.urlPrefix,A!=this.urlPrefix}setShowLinkBrackets(){const A=this.showLinkBrackets,e=this.app.metadataCache.getFileCache(this.file);return(null==e?void 0:e.frontmatter)&&null!=e.frontmatter["excalidraw-link-brackets"]?this.showLinkBrackets=0!=e.frontmatter["excalidraw-link-brackets"]:this.showLinkBrackets=this.plugin.settings.showLinkBrackets,A!=this.showLinkBrackets}setFile(A,e){if(!e)return;if(this.files.set(A,e),!e.file)return;const t=e.linkParts.original.split("#");this.plugin.filesMaster.set(A,{path:e.file.path,blockrefData:1===t.length?null:t[1],hasSVGwithBitmap:e.isSVGwithBitmap})}getFiles(){return Object.values(this.files)}getFile(A){let e=this.files.get(A);if(e)return e;const t=this.plugin.filesMaster.get(A);return t?(e=new EmbeddedFile(this.plugin,this.file.path,t.blockrefData?t.path+"#"+t.blockrefData:t.path),this.files.set(A,e),e):e}getFileEntries(){return this.files.entries()}deleteFile(A){this.files.delete(A)}hasFile(A){if(this.files.has(A))return!0;if(this.plugin.filesMaster.has(A)){const e=this.plugin.filesMaster.get(A);if(!this.app.vault.getAbstractFileByPath(e.path))return this.plugin.filesMaster.delete(A),!0;const t=new EmbeddedFile(this.plugin,this.file.path,e.blockrefData?e.path+"#"+e.blockrefData:e.path);return this.files.set(A,t),!0}return!1}setEquation(A,e){this.equations.set(A,{latex:e.latex,isLoaded:e.isLoaded}),this.plugin.equationsMaster.set(A,e.latex)}getEquation(A){let e=this.equations.get(A);if(e)return e;const t=this.plugin.equationsMaster.get(A);return t?(this.equations.set(A,{latex:t,isLoaded:!1}),{latex:t,isLoaded:!1}):e}getEquationEntries(){return this.equations.entries()}deleteEquation(A){this.equations.delete(A)}hasEquation(A){return!!this.equations.has(A)||!!this.plugin.equationsMaster.has(A)&&(this.equations.set(A,{latex:this.plugin.equationsMaster.get(A),isLoaded:!1}),!0)}}const getTransclusion=async(A,e,t,i)=>{var n,a,s,r,o,l,c,d,h,g;if(!A.path)return{contents:A.original.trim(),lineNum:0};if(!(t&&t instanceof obsidian.TFile))return{contents:A.original.trim(),lineNum:0};const u=await e.vault.read(t);if(!A.ref)return i?{contents:u.substring(0,i).trim(),lineNum:0}:{contents:u.trim(),lineNum:0};const w=(await e.metadataCache.blockCache.getForFile({isCancelled:()=>!1},t)).blocks.filter((A=>"comment"!=A.node.type));if(!w)return{contents:A.original.trim(),lineNum:0};if(A.isBlockRef){let e=null===(n=w.filter((e=>e.node.id==A.ref))[0])||void 0===n?void 0:n.node;if(!e)return{contents:A.original.trim(),lineNum:0};["blockquote","listItem"].includes(e.type)&&(e=e.children[0]);const t=e.position.start.offset,i=e.position.start.line,s=(null===(a=e.children[e.children.length-1])||void 0===a?void 0:a.position.start.offset)-1;return{contents:u.substring(t,s).trim(),lineNum:i}}const p=w.filter((A=>0===A.display.search(/^#+\s/)));let B=null,m=0,f=null,E=1;for(let e=0;eE;)A++;return A===p.length&&p[A-1].node.depth>E?{leadingHashes:"#".repeat(E)+" ",contents:u.substring(B).trim(),lineNum:m}:(f=p[A].node.position.start.offset-1,{leadingHashes:"#".repeat(E)+" ",contents:u.substring(B,f).trim(),lineNum:m})}const t=p[e].node.children[0],i=null===(r=null===(s=p[e].node.data)||void 0===s?void 0:s.hProperties)||void 0===r?void 0:r.dataHeading,n=null==t?void 0:t.children;!B&&((null===(o=null==t?void 0:t.value)||void 0===o?void 0:o.replaceAll(REG_BLOCK_REF_CLEAN,""))===A.ref||(null===(l=null==t?void 0:t.title)||void 0===l?void 0:l.replaceAll(REG_BLOCK_REF_CLEAN,""))===A.ref||(null==i?void 0:i.replaceAll(REG_BLOCK_REF_CLEAN,""))===A.ref||n&&(null===(d=null===(c=n[0])||void 0===c?void 0:c.value)||void 0===d?void 0:d.replaceAll(REG_BLOCK_REF_CLEAN,""))===A.ref)&&(B=null===(h=p[e].node.children[0])||void 0===h?void 0:h.position.start.offset,E=p[e].node.depth,m=null===(g=p[e].node.children[0])||void 0===g?void 0:g.position.start.line)}return B?{leadingHashes:"#".repeat(E)+" ",contents:u.substring(B).trim(),lineNum:m}:{contents:A.original.trim(),lineNum:0}};class Prompt extends obsidian.Modal{constructor(A,e,t,i,n){super(A),this.prompt_text=e,this.default_value=t,this.placeholder=i,this.prompt_desc=n}onOpen(){this.titleEl.setText(this.prompt_text),this.createForm()}onClose(){this.contentEl.empty()}createForm(){var A;let e=this.contentEl.createDiv();e.addClass("excalidraw-prompt-div"),this.prompt_desc&&(e=e.createDiv(),e.style.width="100%",e.createEl("p").innerHTML=this.prompt_desc);const t=e.createEl("form");t.addClass("excalidraw-prompt-form"),t.type="submit",t.onsubmit=A=>{A.preventDefault(),this.resolve(this.promptEl.value),this.close()},this.promptEl=t.createEl("input"),this.promptEl.type="text",this.promptEl.placeholder=this.placeholder,this.promptEl.value=null!==(A=this.default_value)&&void 0!==A?A:"",this.promptEl.addClass("excalidraw-prompt-input"),this.promptEl.select()}async openAndGetValue(A){this.resolve=A,this.open()}}class GenericInputPrompt extends obsidian.Modal{constructor(A,e,t,i,n){super(A),this.header=e,this.didSubmit=!1,this.submitClickCallback=()=>this.submit(),this.cancelClickCallback=()=>this.cancel(),this.submitEnterCallback=A=>{"Enter"===A.key&&(A.preventDefault(),this.submit())},this.placeholder=t,this.input=i,this.buttons=n,this.waitForClose=new Promise(((A,e)=>{this.resolvePromise=A,this.rejectPromise=e})),this.display(),this.open()}static Prompt(A,e,t,i,n){return new GenericInputPrompt(A,e,t,i,n).waitForClose}display(){this.contentEl.empty(),this.titleEl.textContent=this.header;const A=this.contentEl.createDiv();this.inputComponent=this.createInputField(A,this.placeholder,this.input),this.createButtonBar(A)}createInputField(A,e,t){const i=new obsidian.TextComponent(A);return i.inputEl.style.width="100%",i.setPlaceholder(null!=e?e:"").setValue(null!=t?t:"").onChange((A=>this.input=A)).inputEl.addEventListener("keydown",this.submitEnterCallback),i}createButton(A,e,t){const i=new obsidian.ButtonComponent(A);return i.setButtonText(e).onClick(t),i}createButtonBar(A){const e=A.createDiv();if(this.buttons&&this.buttons.length>0){let A=null;for(const t of this.buttons){const i=new obsidian.ButtonComponent(e);i.setButtonText(t.caption).onClick((A=>{const e=t.action(this.input);e&&(this.input=e),this.submit()})),A=null!=A?A:i}A&&(A.setCta().buttonEl.style.marginRight="0")}else this.createButton(e,"Ok",this.submitClickCallback).setCta().buttonEl.style.marginRight="0";this.createButton(e,"Cancel",this.cancelClickCallback),e.style.display="flex",e.style.flexDirection="row-reverse",e.style.justifyContent="flex-start",e.style.marginTop="1rem"}submit(){this.didSubmit=!0,this.close()}cancel(){this.close()}resolveInput(){this.didSubmit?this.resolvePromise(this.input):this.rejectPromise("No input given.")}removeInputListener(){var A,e;null===(e=null===(A=this.inputComponent)||void 0===A?void 0:A.inputEl)||void 0===e||e.removeEventListener("keydown",this.submitEnterCallback)}onOpen(){super.onOpen(),this.inputComponent.inputEl.focus(),this.inputComponent.inputEl.select()}onClose(){super.onClose(),this.resolveInput(),this.removeInputListener()}}class GenericSuggester extends obsidian.FuzzySuggestModal{constructor(A,e,t,i,n){var a;super(A),this.displayItems=e,this.items=t,this.hint=i,this.instructions=n,this.limit=20,this.setPlaceholder(null!==(a=this.hint)&&void 0!==a?a:""),n&&this.setInstructions(this.instructions),this.promise=new Promise(((A,e)=>{this.resolvePromise=A,this.rejectPromise=e})),this.open()}static Suggest(A,e,t,i,n){return new GenericSuggester(A,e,t,i,n).promise}getItemText(A){return this.displayItems[this.items.indexOf(A)]}getItems(){return this.items}selectSuggestion(A,e){this.resolved=!0,super.selectSuggestion(A,e)}onChooseItem(A){this.resolved=!0,this.resolvePromise(A)}onClose(){super.onClose(),this.resolved||this.rejectPromise(this.inputEl.value)}}class NewFileActions extends obsidian.Modal{constructor(A,e,t,i,n){super(A.app),this.plugin=A,this.path=e,this.newPane=t,this.newWindow=i,this.view=n}onOpen(){this.createForm()}async onClose(){}openFile(A){A&&(this.newWindow?app.workspace.openPopoutLeaf():this.newPane?getNewOrAdjacentLeaf(this.plugin,this.view.leaf):this.view.leaf).openFile(A,{active:!0})}createForm(){this.titleEl.setText("New File"),this.contentEl.createDiv({cls:"excalidraw-prompt-center",text:"File does not exist. Do you want to create it?"}),this.contentEl.createDiv({cls:"excalidraw-prompt-center filepath",text:this.path}),this.contentEl.createDiv({cls:"excalidraw-prompt-center"},(A=>{A.style.textAlign="right";const e=()=>this.path&&""!==this.path?!!this.view.file||(new obsidian.Notice("Unknown error. It seems as if your drawing was closed or the drawing file is missing"),!1):(new obsidian.Notice("Error: Filename for new file may not be empty"),!1),t=async A=>{if(!this.path.includes("/")){const A=new RegExp(`${this.view.file.name}$`,"g");this.path=this.view.file.path.replace(A,this.path)}return this.path.match(/\.md$/)||(this.path=`${this.path}.md`),await this.app.vault.create(this.path,A)};A.createEl("button",{text:"Create Markdown"}).onclick=async()=>{if(!e)return;const A=await t("");this.openFile(A),this.close()},A.createEl("button",{text:"Create Excalidraw"}).onclick=async()=>{if(!e)return;const A=await t(await this.plugin.getBlankDrawing());await sleep$1(200),this.openFile(A),this.close()},A.createEl("button",{text:"Never Mind"}).onclick=()=>{this.close()}}))}}class ScriptEngine{constructor(A){this.plugin=A,this.scriptIconMap={},this.loadScripts(),this.registerEventHandlers()}registerEventHandlers(){const A=A=>{if(!A.endsWith(".svg"))return;const e=this.plugin.app.vault.getAbstractFileByPath(getIMGFilename(A,"md"));e&&e instanceof obsidian.TFile&&(this.unloadScript(this.getScriptName(e),e.path),this.loadScript(e))};this.plugin.registerEvent(this.plugin.app.vault.on("delete",(async e=>{e instanceof obsidian.TFile&&e.path.startsWith(this.scriptPath)&&(this.unloadScript(this.getScriptName(e),e.path),A(e.path))}))),this.plugin.registerEvent(this.plugin.app.vault.on("create",(async e=>{e instanceof obsidian.TFile&&e.path.startsWith(this.scriptPath)&&(this.loadScript(e),A(e.path))}))),this.plugin.registerEvent(this.plugin.app.vault.on("rename",(async(e,t)=>{if(!(e instanceof obsidian.TFile))return;const i=t.startsWith(this.scriptPath),n=e.path.startsWith(this.scriptPath);i&&(this.unloadScript(this.getScriptName(t),t),A(t)),n&&(this.loadScript(e),A(e.path))})))}updateScriptPath(){this.scriptPath!==this.plugin.settings.scriptFolderPath&&(this.scriptPath&&this.unloadScripts(),this.loadScripts())}getListofScripts(){const A=this.plugin.app;if(this.scriptPath=this.plugin.settings.scriptFolderPath,A.vault.getAbstractFileByPath(this.scriptPath))return A.vault.getFiles().filter((A=>A.path.startsWith(this.scriptPath)&&"md"===A.extension));this.scriptPath=null}loadScripts(){var A;null===(A=this.getListofScripts())||void 0===A||A.forEach((A=>this.loadScript(A)))}getScriptName(A){let e="",t="";A instanceof obsidian.TFile?(e=A.basename,t=A.path):(e=splitFolderAndFilename(A).basename,t=A);const i=t.split(`${this.scriptPath}/`)[1],n=i.lastIndexOf("/");return n>-1?i.substring(0,n+1)+e:e}async addScriptIconToMap(A,e){const t=getIMGFilename(A,"svg"),i=this.plugin.app.vault.getAbstractFileByPath(t),n=i&&i instanceof obsidian.TFile?await this.plugin.app.vault.read(i):null;this.scriptIconMap=Object.assign({},this.scriptIconMap),this.scriptIconMap[A]={name:e,svgString:n},this.updateToolPannels()}loadScript(A){if("md"!==A.extension)return;const e=this.getScriptName(A);this.addScriptIconToMap(A.path,e),this.plugin.addCommand({id:e,name:`(Script) ${e}`,checkCallback:t=>{if(t)return Boolean(app.workspace.getActiveViewOfType(ExcalidrawView));const i=app.workspace.getActiveViewOfType(ExcalidrawView);return!!i&&((async()=>{const t=await this.plugin.app.vault.read(A);t&&this.executeScript(i,t,e)})(),!0)}})}unloadScripts(){this.plugin.app.vault.getFiles().filter((A=>A.path.startsWith(this.scriptPath))).forEach((A=>{this.unloadScript(this.getScriptName(A),A.path)}))}unloadScript(A,e){if(!e.endsWith(".md"))return;delete this.scriptIconMap[e],this.scriptIconMap=Object.assign({},this.scriptIconMap),this.updateToolPannels();const t=this.plugin.app,i=`${PLUGIN_ID}:${A}`;t.commands.commands[i]&&delete t.commands.commands[i]}async executeScript(A,e,t){if(!A||!e||!t)return;this.plugin.ea.reset(),this.plugin.ea.setView(A),this.plugin.ea.activeScript=t;const i=Object.getPrototypeOf((async()=>{})).constructor;let n=null;return n=await new i("ea","utils",e)(this.plugin.ea,{inputPrompt:(A,e,t,i)=>ScriptEngine.inputPrompt(this.plugin.app,A,e,t,i),suggester:(A,e,t,i)=>ScriptEngine.suggester(this.plugin.app,A,e,t,i)}),this.plugin.ea.activeScript=null,n}updateToolPannels(){this.plugin.app.workspace.getLeavesOfType("excalidraw").forEach((A=>{var e,t;null===(t=null===(e=A.view.toolsPanelRef)||void 0===e?void 0:e.current)||void 0===t||t.updateScriptIconMap(this.scriptIconMap)}))}static async inputPrompt(A,e,t,i,n){try{return await GenericInputPrompt.Prompt(A,e,t,i,n)}catch(A){return}}static async suggester(A,e,t,i,n){try{return await GenericSuggester.Suggest(A,e,t,i,n)}catch(A){return}}}const{determineFocusDistance:determineFocusDistance,intersectElementWithLine:intersectElementWithLine,getCommonBoundingBox:getCommonBoundingBox,getMaximumGroups:getMaximumGroups,measureText:measureText}=excalidrawLib,GAP=4;class ExcalidrawAutomate{constructor(A,e){this.targetView=null,this.mostRecentMarkdownSVG=null,this.onViewUnloadHook=null,this.onViewModeChangeHook=null,this.onLinkHoverHook=null,this.onLinkClickHook=null,this.onDropHook=null,this.activeScript=null,this.plugin=A,this.reset(),this.targetView=e}getAPI(A){return new ExcalidrawAutomate(this.plugin,A)}setFillStyle(A){switch(A){case 0:return this.style.fillStyle="hachure","hachure";case 1:return this.style.fillStyle="cross-hatch","cross-hatch";default:return this.style.fillStyle="solid","solid"}}setStrokeStyle(A){switch(A){case 0:return this.style.strokeStyle="solid","solid";case 1:return this.style.strokeStyle="dashed","dashed";default:return this.style.strokeStyle="dotted","dotted"}}setStrokeSharpness(A){return 0===A?(this.style.strokeSharpness="round","round"):(this.style.strokeSharpness="sharp","sharp")}setFontFamily(A){switch(A){case 1:return this.style.fontFamily=4,getFontFamily(4);case 2:return this.style.fontFamily=2,getFontFamily(2);case 3:return this.style.fontFamily=3,getFontFamily(3);default:return this.style.fontFamily=1,getFontFamily(1)}}setTheme(A){return 0===A?(this.canvas.theme="light","light"):(this.canvas.theme="dark","dark")}addToGroup(A){const e=nanoid();return A.forEach((A=>{var t,i;null===(i=null===(t=this.elementsDict[A])||void 0===t?void 0:t.groupIds)||void 0===i||i.push(e)})),e}async toClipboard(A){const e=A?await getTemplate(this.plugin,A,!1,new EmbeddedFilesLoader(this.plugin),0):null;let t=e?e.elements:[];t=t.concat(this.getElements()),navigator.clipboard.writeText(JSON.stringify({type:"excalidraw/clipboard",elements:t}))}getElements(){const A=[],e=Object.keys(this.elementsDict);for(let t=0;t{const l=t+Math.random()*s-s/2;o.push([l+Math.random()*s-s/2+t%2*s/6+A,i*Math.sqrt(n*n*(1-l*l/(a*a)))+Math.random()*r-r/2+t%2*r/6+e])};let c;for(c=s/2-a;c<=a-s/2;c+=a/6)l(c,1);for(c=a-s/2;c>=s/2-a;c-=a/6)l(c,-1);o.push(o[0]);const d=this.addLine((A=>{const e=getLineBox(A),n=t/e.w,a=i/e.h;let s;for(s=0;s500){const A=500/Math.max(a.size.width,a.size.height);a.size.width=A*a.size.width,a.size.height=A*a.size.height}return this.elementsDict[i]=this.boxedElement(i,"image",A,e,a.size.width,a.size.height),this.elementsDict[i].fileId=s,this.elementsDict[i].scale=[1,1],i}async addLaTex(A,e,t){const i=nanoid(),n=await tex2dataURL(t,this.plugin);return n?(this.imagesDict[n.fileId]={mimeType:n.mimeType,id:n.fileId,dataURL:n.dataURL,created:n.created,file:null,hasSVGwithBitmap:!1,latex:t},this.elementsDict[i]=this.boxedElement(i,"image",A,e,n.size.width,n.size.height),this.elementsDict[i].fileId=n.fileId,this.elementsDict[i].scale=[1,1],i):null}connectObjects(A,e,t,i,n){if(!this.elementsDict[A]||!this.elementsDict[t])return;if(["line","arrow","freedraw"].includes(this.elementsDict[A].type)||["line","arrow","freedraw"].includes(this.elementsDict[t].type))return;const a=(null==n?void 0:n.padding)?n.padding:10,s=(null==n?void 0:n.numberOfPoints)?n.numberOfPoints:0,r=(A,e)=>{switch(A){case"bottom":return[(e.x+(e.x+e.width))/2,e.y+e.height+a];case"left":return[e.x-a,(e.y+(e.y+e.height))/2];case"right":return[e.x+e.width+a,(e.y+(e.y+e.height))/2];default:return[(e.x+(e.x+e.width))/2,e.y-a]}};let o,l,c,d;const h=this.elementsDict[A],g=this.elementsDict[t];if(!e||!i){const A=h.x+h.width/2,t=g.x+g.width/2,n=h.y+h.height/2,a=g.y+g.height/2;if(!e){const e=intersectElementWithLine(h,[t,a],[A,n],4);0===e.length?[o,l]=[A,n]:[o,l]=e[0]}if(!i){const e=intersectElementWithLine(g,[A,n],[t,a],4);0===e.length?[c,d]=[t,a]:[c,d]=e[0]}}e&&([o,l]=r(e,this.elementsDict[A])),i&&([c,d]=r(i,this.elementsDict[t]));const u=s+2,w=[];for(let A=0;AMath.PI/2&&(i-=Math.PI),this.style.angle=i;const a=this.addText(t.x+t.points[1][0]/2-n.width/2,t.y+t.points[1][1]/2-n.height,e);return this.style.angle=0,a}clear(){this.elementsDict={},this.imagesDict={}}reset(){this.clear(),this.activeScript=null,this.style={strokeColor:"#000000",backgroundColor:"transparent",angle:0,fillStyle:"hachure",strokeWidth:1,strokeStyle:"solid",roughness:1,opacity:100,strokeSharpness:"sharp",fontFamily:1,fontSize:20,textAlign:"left",verticalAlign:"top",startArrowHead:null,endArrowHead:"arrow"},this.canvas={theme:"light",viewBackgroundColor:"#FFFFFF",gridSize:0}}isExcalidrawFile(A){return this.plugin.isExcalidrawFile(A)}setView(A){if("active"==A){const A=this.plugin.app.workspace.getActiveViewOfType(ExcalidrawView);if(!(A instanceof ExcalidrawView))return;this.targetView=A}if("first"==A){const A=this.plugin.app.workspace.getLeavesOfType("excalidraw");if(!A||0==A.length)return;this.targetView=A[0].view}return A instanceof ExcalidrawView&&(this.targetView=A),this.targetView}getExcalidrawAPI(){var A;return this.targetView&&(null===(A=this.targetView)||void 0===A?void 0:A._loaded)?this.targetView.excalidrawAPI:(errorMessage("targetView not set","getExcalidrawAPI()"),null)}getViewElements(){var A,e,t;if(!this.targetView||!(null===(A=this.targetView)||void 0===A?void 0:A._loaded))return errorMessage("targetView not set","getViewSelectedElements()"),[];const i=null===(t=null===(e=this.targetView)||void 0===e?void 0:e.excalidrawRef)||void 0===t?void 0:t.current;return i?null==i?void 0:i.getSceneElements():[]}deleteViewElements(A){var e,t,i;if(!this.targetView||!(null===(e=this.targetView)||void 0===e?void 0:e._loaded))return errorMessage("targetView not set","getViewSelectedElements()"),!1;const n=null===(i=null===(t=this.targetView)||void 0===t?void 0:t.excalidrawRef)||void 0===i?void 0:i.current;if(!n)return!1;const a=n.getSceneElements(),s=n.getAppState();return this.targetView.updateScene({elements:a.filter((e=>!A.includes(e))),appState:s,commitToHistory:!0}),!0}getViewSelectedElement(){const A=this.getViewSelectedElements();return A?A[0]:null}getViewSelectedElements(){var A;return this.targetView&&(null===(A=this.targetView)||void 0===A?void 0:A._loaded)?this.targetView.getViewSelectedElements():(errorMessage("targetView not set","getViewSelectedElements()"),[])}getViewFileForImageElement(A){var e,t,i,n;return this.targetView&&(null===(e=this.targetView)||void 0===e?void 0:e._loaded)?A&&"image"===A.type?null===(n=null===(i=null===(t=this.targetView)||void 0===t?void 0:t.excalidrawData)||void 0===i?void 0:i.getFile(A.fileId))||void 0===n?void 0:n.file:(errorMessage("Must provide an image element as input","getViewFileForImageElement()"),null):(errorMessage("targetView not set","getViewSelectedElements()"),null)}copyViewElementsToEAforEditing(A){A.forEach((A=>{this.elementsDict[A.id]=Object.assign(Object.assign({},A),{version:A.version+1,updated:Date.now(),versionNonce:Math.floor(1e9*Math.random())})}))}viewToggleFullScreen(A=!1){var e;if(this.plugin.app.isMobile)return void errorMessage("mobile not supported","viewToggleFullScreen()");if(!this.targetView||!(null===(e=this.targetView)||void 0===e?void 0:e._loaded))return void errorMessage("targetView not set","viewToggleFullScreen()");if(A){const A=this.getExcalidrawAPI();this.targetView.updateScene({appState:Object.assign({viewModeEnabled:!0},A.appState),commitToHistory:!1})}const t=this.targetView;t.isFullscreen()?t.exitFullscreen():t.gotoFullscreen()}connectObjectWithViewSelectedElement(A,e,t,i){const n=this.getViewSelectedElement();if(!n)return!1;const a=n.id;return this.elementsDict[a]=n,this.connectObjects(A,e,a,t,i),delete this.elementsDict[a],!0}async addElementsToView(A=!1,e=!0,t=!1){var i;if(!this.targetView||!(null===(i=this.targetView)||void 0===i?void 0:i._loaded))return errorMessage("targetView not set","addElementsToView()"),!1;const n=this.getElements();return await this.targetView.addElements(n,A,e,this.imagesDict,t)}registerThisAsViewEA(){var A;return this.targetView&&(null===(A=this.targetView)||void 0===A?void 0:A._loaded)?(this.targetView.setHookServer(this),!0):(errorMessage("targetView not set","addElementsToView()"),!1)}deregisterThisAsViewEA(){var A;return this.targetView&&(null===(A=this.targetView)||void 0===A?void 0:A._loaded)?(this.targetView.setHookServer(this),!0):(errorMessage("targetView not set","addElementsToView()"),!1)}getEmbeddedFilesLoader(A){return new EmbeddedFilesLoader(this.plugin,A)}getExportSettings(A,e){return{withBackground:A,withTheme:e}}getBoundingBox(A){const e=getCommonBoundingBox(A);return{topX:e.minX,topY:e.minY,width:e.maxX-e.minX,height:e.maxY-e.minY}}getMaximumGroups(A){return getMaximumGroups(A)}getLargestElement(A){if(!A||0===A.length)return null;let e=A[0];const t=A=>A.height*A.width;let i=t(A[0]);for(let n=1;ni&&(i=a,e=A[n])}return e}intersectElementWithLine(A,e,t,i){return intersectElementWithLine(A,e,t,i)}getScriptSettings(){var A;return this.activeScript?null!==(A=this.plugin.settings.scriptEngineSettings[this.activeScript])&&void 0!==A?A:{}:null}async setScriptSettings(A){if(!this.activeScript)return null;this.plugin.settings.scriptEngineSettings[this.activeScript]=A,await this.plugin.saveSettings()}openFileInNewOrAdjacentLeaf(A){if(!(A&&A instanceof obsidian.TFile))return null;if(!this.targetView)return null;const e=getNewOrAdjacentLeaf(this.plugin,this.targetView.leaf);return e.openFile(A,{active:!1}),e}measureText(A){var e,t;const i=_measureText(A,this.style.fontSize,this.style.fontFamily);return{width:null!==(e=i.w)&&void 0!==e?e:0,height:null!==(t=i.h)&&void 0!==t?t:0}}verifyMinimumPluginVersion(A){return PLUGIN_VERSION>=A}isExcalidrawView(A){return A instanceof ExcalidrawView}selectElementsInView(A){var e;this.targetView&&(null===(e=this.targetView)||void 0===e?void 0:e._loaded)?A&&0!==A.length&&this.getExcalidrawAPI().selectElements(A):errorMessage("targetView not set","selectElementsInView()")}generateElementId(){return nanoid()}cloneElement(A){const e=JSON.parse(JSON.stringify(A));return e.id=nanoid(),e}moveViewElementToZIndex(A,e){var t;if(!this.targetView||!(null===(t=this.targetView)||void 0===t?void 0:t._loaded))return void errorMessage("targetView not set","moveViewElementToZIndex()");const i=this.getExcalidrawAPI(),n=this.getViewElements(),a=n.filter((e=>e.id===A));if(0===a.length)return void errorMessage(`Element (id: ${A}) not found`,"moveViewElementToZIndex");if(e>=n.length)return void i.bringToFront(a);if(e<0)return void i.sendToBack(a);const s=n.indexOf(a[0]);n.splice(e,0,n.splice(s,1)[0]),this.targetView.updateScene({elements:n,commitToHistory:!0})}hexStringToRgb(A){const e=/^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(A);return[parseInt(e[1],16),parseInt(e[2],16),parseInt(e[3],16)]}rgbToHexString(A){const e=(((255&Math.round(A[0]))<<16)+((255&Math.round(A[1]))<<8)+(255&Math.round(A[2]))).toString(16).toLowerCase();return`#${"000000".substring(e.length)}${e}`}hslToRgb(A){const e=A[0]/360,t=A[1]/100,i=A[2]/100;let n,a,s;if(0===t)return s=255*i,[s,s,s];n=i<.5?i*(1+t):i+t-i*t;const r=2*i-n,o=[0,0,0];for(let A=0;A<3;A++)a=e+1/3*-(A-1),a<0&&a++,a>1&&a--,s=6*a<1?r+6*(n-r)*a:2*a<1?n:3*a<2?r+(n-r)*(2/3-a)*6:r,o[A]=255*s;return o}rgbToHsl(A){const e=A[0]/255,t=A[1]/255,i=A[2]/255,n=Math.min(e,t,i),a=Math.max(e,t,i),s=a-n;let r,o;a===n?r=0:e===a?r=(t-i)/s:t===a?r=2+(i-e)/s:i===a&&(r=4+(e-t)/s),r=Math.min(60*r,360),r<0&&(r+=360);const l=(n+a)/2;return o=a===n?0:l<=.5?s/(a+n):s/(2-a-n),[r,100*o,100*l]}colorNameToHex(A){return COLOR_NAMES.has(A.toLowerCase().trim())?COLOR_NAMES.get(A.toLowerCase().trim()):A.trim()}}async function initExcalidrawAutomate(A){await initFonts();const e=new ExcalidrawAutomate(A);return window.ExcalidrawAutomate=e,e}function destroyExcalidrawAutomate(){delete window.ExcalidrawAutomate}function normalizeLinePoints(A){const e=[],[t,i]=A[0];for(let n=0;n-1||e.search("excalidraw-plugin: locked\n")>-1;await a.loadData(e,o,r?TextMode.parsed:TextMode.raw);let c=e.search("# Text Elements\n");-1==c&&(c=e.search("# Drawing\n"));let d=a.scene;return t&&await i.loadSceneFiles(a,(A=>{if(A&&0!==A.length){for(const e of A)e.hasSVGwithBitmap&&(l=!0),a.scene.files[e.id]={mimeType:e.mimeType,id:e.id,dataURL:e.dataURL,created:e.created};d=scaleLoadedImage(a.scene,A).scene}}),n),{elements:d.elements,appState:d.appState,frontmatter:e.substring(0,c),files:d.files,hasSVGwithBitmap:l}}return{elements:[],appState:{},frontmatter:null,files:[],hasSVGwithBitmap:l}}async function createPNG(A,e=1,t,i,n,a,s,r=[],o,l){var c,d,h,g,u,w,p,B;i||(i=new EmbeddedFilesLoader(o));const m=A?await getTemplate(o,A,!0,i,l):null;let f=null!==(c=null==m?void 0:m.elements)&&void 0!==c?c:[];return f=f.concat(r),await getPNG({type:"excalidraw",version:2,source:"https://excalidraw.com",elements:f,appState:{theme:null!==(h=null!=n?n:null===(d=null==m?void 0:m.appState)||void 0===d?void 0:d.theme)&&void 0!==h?h:a,viewBackgroundColor:null!==(u=null===(g=null==m?void 0:m.appState)||void 0===g?void 0:g.viewBackgroundColor)&&void 0!==u?u:s},files:null!==(w=null==m?void 0:m.files)&&void 0!==w?w:{}},{withBackground:null!==(p=null==t?void 0:t.withBackground)&&void 0!==p?p:o.settings.exportWithBackground,withTheme:null!==(B=null==t?void 0:t.withTheme)&&void 0!==B?B:o.settings.exportWithTheme},e)}async function createSVG(A,e=!1,t,i,n,a,s,r=[],o,l,c){var d,h,g,u,w,p,B,m;i||(i=new EmbeddedFilesLoader(o));const f=A?await getTemplate(o,A,!0,i,l):null;let E=null!==(d=null==f?void 0:f.elements)&&void 0!==d?d:[];E=E.concat(r);const C=await getSVG({type:"excalidraw",version:2,source:"https://excalidraw.com",elements:E,appState:{theme:null!==(g=null!=n?n:null===(h=null==f?void 0:f.appState)||void 0===h?void 0:h.theme)&&void 0!==g?g:a,viewBackgroundColor:null!==(w=null===(u=null==f?void 0:f.appState)||void 0===u?void 0:u.viewBackgroundColor)&&void 0!==w?w:s},files:null!==(p=null==f?void 0:f.files)&&void 0!==p?p:{}},{withBackground:null!==(B=null==t?void 0:t.withBackground)&&void 0!==B?B:o.settings.exportWithBackground,withTheme:null!==(m=null==t?void 0:t.withTheme)&&void 0!==m?m:o.settings.exportWithTheme},null!=c?c:o.settings.exportPaddingSVG);return(null==f?void 0:f.hasSVGwithBitmap)&&C.setAttribute("hasbitmap","true"),e?embedFontsInSVG(C,o):C}function estimateLineBound(A){let e=1/0,t=1/0,i=-1/0,n=-1/0;for(const[a,s]of A)e=Math.min(e,a),t=Math.min(t,s),i=Math.max(i,a),n=Math.max(n,s);return[e,t,i,n]}function estimateBounds(A){const e=getCommonBoundingBox(A);return[e.minX,e.minY,e.maxX,e.maxY]}function repositionElementsToCursor(A,e,t=!1){const[i,n,a,s]=estimateBounds(A);let[r,o]=[0,0];return[r,o]=t?[e.x-(i+a)/2,e.y-(n+s)/2]:[e.x-i,e.y-n],A.forEach((A=>{A.x=A.x+r,A.y=A.y+o})),A}function errorMessage(A,e){switch(A){case"targetView not set":errorlog({where:"ExcalidrawAutomate",source:e,message:"targetView not set, or no longer active. Use setView before calling this function"});break;case"mobile not supported":errorlog({where:"ExcalidrawAutomate",source:e,message:"this function is not avalable on Obsidian Mobile"});break;default:errorlog({where:"ExcalidrawAutomate",source:e,message:"unknown error"})}}const insertLaTeXToView=A=>{const e=A.plugin.app,i=A.plugin.ea;new Prompt(e,t("ENTER_LATEX"),"","\\color{red}\\oint_S {E_n dA = \\frac{1}{{\\varepsilon _0 }}} Q_{inside}").openAndGetValue((async e=>{e&&(i.reset(),await i.addLaTex(0,0,e),i.setView(A),i.addElementsToView(!0,!1,!0))}))},search=async A=>{const e=A.plugin.ea;e.reset(),e.setView(A);const t=e.getViewElements().filter((A=>"text"===A.type));if(0===t.length)return;let i=await ScriptEngine.inputPrompt(A.plugin.app,"Search for","use quotation marks for exact match","");if(!i)return;const n=i.matchAll(/"(.*?)"/g);let a,s=[];for(;!(a=n.next()).done;)s.push(a.value[1]);i=i.replaceAll(/"(.*?)"/g,""),s=s.concat(i.split(" ").filter((A=>0!==A.length))),e.targetView.selectElementsMatchingQuery(t,s)},URL$1="https://raw.githubusercontent.com/zsviczian/obsidian-excalidraw-plugin/master/ea-scripts/index-new.md";class ScriptInstallPrompt extends obsidian.Modal{constructor(A){super(A.app),this.plugin=A}async onOpen(){this.contentEl.classList.add("excalidraw-scriptengine-install"),this.containerEl.classList.add("excalidraw-scriptengine-install");try{const A=await obsidian.request({url:URL$1});if(!A)return new obsidian.Notice("Error opening the Excalidraw Script Store page. Please double check that you can access the website. I've logged the link in developer console (press CTRL+SHIFT+i)",5e3),log(URL$1),void this.close();await obsidian.MarkdownRenderer.renderMarkdown(A,this.contentEl,"",this.plugin),this.contentEl.querySelectorAll("h1[data-heading],h2[data-heading],h3[data-heading]").forEach((A=>{A.setAttribute("id",A.getAttribute("data-heading"))})),this.contentEl.querySelectorAll("a.internal-link").forEach((A=>{A.removeAttribute("target")}))}catch(A){errorlog({where:"ScriptInstallPrompt.onOpen",error:A}),new obsidian.Notice("Could not open ScriptEngine repository"),this.close()}}onClose(){this.contentEl.empty()}}function toVal(A){var e,t,i="";if("string"==typeof A||"number"==typeof A)i+=A;else if("object"==typeof A)if(Array.isArray(A))for(e=0;eReact__namespace.createElement("label",{className:clsx("ToolIcon ToolIcon_type_floating","ToolIcon_size_medium",{"is-mobile":A}),onClick:()=>{this.toolsRef.current.setTheme(e.theme),this.toolsRef.current.toggleVisibility(e.zenModeEnabled||A)}},React__namespace.createElement("div",{className:"ToolIcon__icon","aria-hidden":"true"},React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 166 267"},React__namespace.createElement("path",{fill:"transparent",d:"M0 0h165.742v267.245H0z"}),React__namespace.createElement("g",{fillRule:"evenodd"},React__namespace.createElement("path",{fill:"#bd7efc",strokeWidth:"0",d:"M55.5 96.49 39.92 57.05 111.28 10l4.58 36.54L55.5 95.65"}),React__namespace.createElement("path",{fill:"none",stroke:"#410380",strokeWidth:".5",d:"M55.5 96.49c-5.79-14.66-11.59-29.33-15.58-39.44M55.5 96.49c-3.79-9.59-7.58-19.18-15.58-39.44m0 0C60.13 43.72 80.34 30.4 111.28 10M39.92 57.05C60.82 43.27 81.73 29.49 111.28 10m0 0c.97 7.72 1.94 15.45 4.58 36.54M111.28 10c1.14 9.12 2.29 18.24 4.58 36.54m0 0C95.41 63.18 74.96 79.82 55.5 95.65m60.36-49.11C102.78 57.18 89.71 67.82 55.5 95.65m0 0v.84m0-.84v.84"})),React__namespace.createElement("g",{fillRule:"evenodd"},React__namespace.createElement("path",{fill:"#e2c4ff",strokeWidth:"0",d:"m111.234 10.06 44.51 42.07-40.66-5.08-3.85-36.99"}),React__namespace.createElement("path",{fill:"none",stroke:"#410380",strokeWidth:".5",d:"M111.234 10.06c11.83 11.18 23.65 22.36 44.51 42.07m-44.51-42.07 44.51 42.07m0 0c-13.07-1.63-26.13-3.27-40.66-5.08m40.66 5.08c-11.33-1.41-22.67-2.83-40.66-5.08m0 0c-1.17-11.29-2.35-22.58-3.85-36.99m3.85 36.99c-1.47-14.17-2.95-28.33-3.85-36.99m0 0s0 0 0 0m0 0s0 0 0 0"})),React__namespace.createElement("g",{fillRule:"evenodd"},React__namespace.createElement("path",{fill:"#2f005e",strokeWidth:"0",d:"m10 127.778 45.77-32.99-15.57-38.08-30.2 71.07"}),React__namespace.createElement("path",{fill:"none",stroke:"#410380",strokeWidth:".5",d:"M10 127.778c16.85-12.14 33.7-24.29 45.77-32.99M10 127.778c16.59-11.95 33.17-23.91 45.77-32.99m0 0c-6.14-15.02-12.29-30.05-15.57-38.08m15.57 38.08c-4.08-9.98-8.16-19.96-15.57-38.08m0 0c-11.16 26.27-22.33 52.54-30.2 71.07m30.2-71.07c-10.12 23.81-20.23 47.61-30.2 71.07m0 0s0 0 0 0m0 0s0 0 0 0"})),React__namespace.createElement("g",{fillRule:"evenodd"},React__namespace.createElement("path",{fill:"#410380",strokeWidth:"0",d:"m40.208 235.61 15.76-140.4-45.92 32.92 30.16 107.48"}),React__namespace.createElement("path",{fill:"none",stroke:"#410380",strokeWidth:".5",d:"M40.208 235.61c3.7-33.01 7.41-66.02 15.76-140.4m-15.76 140.4c3.38-30.16 6.77-60.32 15.76-140.4m0 0c-10.83 7.76-21.66 15.53-45.92 32.92m45.92-32.92c-11.69 8.38-23.37 16.75-45.92 32.92m0 0c6.84 24.4 13.69 48.8 30.16 107.48m-30.16-107.48c6.67 23.77 13.33 47.53 30.16 107.48m0 0s0 0 0 0m0 0s0 0 0 0"})),React__namespace.createElement("g",{fillRule:"evenodd"},React__namespace.createElement("path",{fill:"#943feb",strokeWidth:"0",d:"m111.234 240.434-12.47 16.67-42.36-161.87 58.81-48.3 40.46 5.25-44.44 188.25"}),React__namespace.createElement("path",{fill:"none",stroke:"#410380",strokeWidth:".5",d:"M111.234 240.434c-3.79 5.06-7.57 10.12-12.47 16.67m12.47-16.67c-4.43 5.93-8.87 11.85-12.47 16.67m0 0c-16.8-64.17-33.59-128.35-42.36-161.87m42.36 161.87c-9.74-37.2-19.47-74.41-42.36-161.87m0 0c15.03-12.35 30.07-24.7 58.81-48.3m-58.81 48.3c22.49-18.47 44.97-36.94 58.81-48.3m0 0c9.48 1.23 18.95 2.46 40.46 5.25m-40.46-5.25c13.01 1.69 26.02 3.38 40.46 5.25m0 0c-10.95 46.41-21.91 92.82-44.44 188.25m44.44-188.25c-12.2 51.71-24.41 103.42-44.44 188.25m0 0s0 0 0 0m0 0s0 0 0 0"})),React__namespace.createElement("g",{fillRule:"evenodd"},React__namespace.createElement("path",{fill:"#6212b3",strokeWidth:"0",d:"m40.379 235.667 15.9-140.21 42.43 161.79-58.33-21.58"}),React__namespace.createElement("path",{fill:"none",stroke:"#410380",strokeWidth:".5",d:"M40.379 235.667c4.83-42.62 9.67-85.25 15.9-140.21m-15.9 140.21c5.84-51.52 11.69-103.03 15.9-140.21m0 0c10.98 41.87 21.96 83.74 42.43 161.79m-42.43-161.79c13.28 50.63 26.56 101.25 42.43 161.79m0 0c-11.8-4.37-23.6-8.74-58.33-21.58m58.33 21.58c-21.73-8.04-43.47-16.08-58.33-21.58m0 0s0 0 0 0m0 0s0 0 0 0"}))))),this.plugin=A,this.toolsRef=e}}class ActionButton extends React__namespace.Component{constructor(A){super(A),this.toastMessageTimeout=0,this.state={visible:!0}}render(){return React__namespace.createElement("button",{style:{width:"fit-content",padding:"2px",margin:"4px"},className:"ToolIcon_type_button ToolIcon_size_small ToolIcon_type_button--show ToolIcon",title:this.props.title,onClick:A=>{this.toastMessageTimeout&&(window.clearTimeout(this.toastMessageTimeout),this.toastMessageTimeout=0),this.props.action(A)},onPointerDown:()=>{this.toastMessageTimeout=window.setTimeout((()=>{var A;return null===(A=this.props.view.excalidrawAPI)||void 0===A?void 0:A.setToastMessage(this.props.title)}),300)}},React__namespace.createElement("div",{className:"ToolIcon__icon","aria-hidden":"true"},this.props.icon))}}const ICONS={exportLibrary:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 200 190"},React__namespace.createElement("g",{fillRule:"evenodd"},React__namespace.createElement("path",{strokeWidth:"0",d:"M50 10h20v20H50"}),React__namespace.createElement("path",{fill:"none",strokeWidth:"2",d:"M50 10h20m-20 0h20m0 0v20m0-20v20m0 0H50m20 0H50m0 0V10m0 20V10"})),React__namespace.createElement("g",{fillRule:"evenodd"},React__namespace.createElement("path",{strokeWidth:"0",d:"M90 10h20v20H90"}),React__namespace.createElement("path",{fill:"none",strokeWidth:"2",d:"M90 10h20m-20 0h20m0 0v20m0-20v20m0 0H90m20 0H90m0 0V10m0 20V10"})),React__namespace.createElement("g",{fillRule:"evenodd"},React__namespace.createElement("path",{strokeWidth:"0",d:"M130 10h20v20h-20"}),React__namespace.createElement("path",{fill:"none",strokeWidth:"2",d:"M130 10h20m-20 0h20m0 0v20m0-20v20m0 0h-20m20 0h-20m0 0V10m0 20V10"})),React__namespace.createElement("g",{fillRule:"evenodd"},React__namespace.createElement("path",{strokeWidth:"0",d:"M170 10h20v20h-20"}),React__namespace.createElement("path",{fill:"none",strokeWidth:"2",d:"M170 10h20m-20 0h20m0 0v20m0-20v20m0 0h-20m20 0h-20m0 0V10m0 20V10"})),React__namespace.createElement("g",{fillRule:"evenodd"},React__namespace.createElement("path",{strokeWidth:"0",d:"M70 50h60v80h20l-50 50-50-50h20V50"}),React__namespace.createElement("path",{fill:"none",strokeWidth:"2",d:"M70 50h60m-60 0h60m0 0v80m0-80v80m0 0h20m-20 0h20m0 0-50 50m50-50-50 50m0 0-50-50m50 50-50-50m0 0h20m-20 0h20m0 0V50m0 80V50m0 0s0 0 0 0m0 0s0 0 0 0m0 0s0 0 0 0m0 0s0 0 0 0"})),React__namespace.createElement("g",{fillRule:"evenodd"},React__namespace.createElement("path",{strokeWidth:"0",d:"M10 10h20v20H10"}),React__namespace.createElement("path",{fill:"none",strokeWidth:"2",d:"M10 10h20m-20 0h20m0 0v20m0-20v20m0 0H10m20 0H10m0 0V10m0 20V10"}))),insertImage:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 512 512"},React__namespace.createElement("path",{d:"M464 64H48C21.49 64 0 85.49 0 112v288c0 26.51 21.49 48 48 48h416c26.51 0 48-21.49 48-48V112c0-26.51-21.49-48-48-48zm-6 336H54a6 6 0 0 1-6-6V118a6 6 0 0 1 6-6h404a6 6 0 0 1 6 6v276a6 6 0 0 1-6 6zM128 152c-22.091 0-40 17.909-40 40s17.909 40 40 40 40-17.909 40-40-17.909-40-40-40zM96 352h320v-80l-87.515-87.515c-4.686-4.686-12.284-4.686-16.971 0L192 304l-39.515-39.515c-4.686-4.686-12.284-4.686-16.971 0L96 304v48z"})),insertMD:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 384 512"},React__namespace.createElement("path",{d:"M288 248v28c0 6.6-5.4 12-12 12H108c-6.6 0-12-5.4-12-12v-28c0-6.6 5.4-12 12-12h168c6.6 0 12 5.4 12 12zm-12 72H108c-6.6 0-12 5.4-12 12v28c0 6.6 5.4 12 12 12h168c6.6 0 12-5.4 12-12v-28c0-6.6-5.4-12-12-12zm108-188.1V464c0 26.5-21.5 48-48 48H48c-26.5 0-48-21.5-48-48V48C0 21.5 21.5 0 48 0h204.1C264.8 0 277 5.1 286 14.1L369.9 98c9 8.9 14.1 21.2 14.1 33.9zm-128-80V128h76.1L256 51.9zM336 464V176H232c-13.3 0-24-10.7-24-24V48H48v416h288z"})),insertLaTeX:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 576 512"},React__namespace.createElement("path",{d:"M571.31 251.31l-22.62-22.62c-6.25-6.25-16.38-6.25-22.63 0L480 274.75l-46.06-46.06c-6.25-6.25-16.38-6.25-22.63 0l-22.62 22.62c-6.25 6.25-6.25 16.38 0 22.63L434.75 320l-46.06 46.06c-6.25 6.25-6.25 16.38 0 22.63l22.62 22.62c6.25 6.25 16.38 6.25 22.63 0L480 365.25l46.06 46.06c6.25 6.25 16.38 6.25 22.63 0l22.62-22.62c6.25-6.25 6.25-16.38 0-22.63L525.25 320l46.06-46.06c6.25-6.25 6.25-16.38 0-22.63zM552 0H307.65c-14.54 0-27.26 9.8-30.95 23.87l-84.79 322.8-58.41-106.1A32.008 32.008 0 0 0 105.47 224H24c-13.25 0-24 10.74-24 24v48c0 13.25 10.75 24 24 24h43.62l88.88 163.73C168.99 503.5 186.3 512 204.94 512c17.27 0 44.44-9 54.28-41.48L357.03 96H552c13.25 0 24-10.75 24-24V24c0-13.26-10.75-24-24-24z"})),insertLink:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 512 512"},React__namespace.createElement("path",{d:"M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"})),exportSVG:React__namespace.createElement("svg",{viewBox:"0 0 28 28"},React__namespace.createElement("text",{style:{fontSize:"28px",fontWeight:"bold"},x:"4",y:"24"},"S")),exportPNG:React__namespace.createElement("svg",{viewBox:"0 0 28 28"},React__namespace.createElement("text",{style:{fontSize:"28px",fontWeight:"bold"},x:"4",y:"24"},"P")),exportExcalidraw:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 100 100"},React__namespace.createElement("g",{transform:"translate(30,5)"},React__namespace.createElement("path",{d:"M14.45 1.715c-2.723 2.148-6.915 5.797-10.223 8.93l-2.61 2.445.477 3.207c.258 1.75.738 5.176 1.031 7.582.332 2.406.66 4.668.773 4.996.145.438 0 .656-.406.656-.699 0-.734-.183 1.176 5.832.7 2.297 1.363 4.414 1.434 4.633.074.254.367.363.699.254.332-.145.515-.438.406-.691-.113-.293.074-.586.367-.696.403-.144.367-.437-.258-1.492-.992-1.64-3.53-15.64-3.675-20.164-.11-3.207-.11-3.242 1.25-5.066 1.324-1.786 4.375-4.485 9.078-7.91 1.324-.985 2.648-2.079 3.015-2.446.551-.656.809-.472 5.442 4.414 2.683 2.805 5.664 5.688 6.617 6.414l1.766 1.313-1.36 2.844c-.734 1.53-3.715 7.437-6.656 13.054-6.137 11.813-4.887 10.68-12.02 10.79l-4.632.038-1.547 1.75c-1.617 1.86-1.836 2.551-1.063 3.72.293.398.512 1.054.512 1.456 0 .656.258.766 1.73.84.918.035 1.762.145 1.875.254.11.11.258 2.371.368 5.031l.144 4.813-2.46 5.25C1.616 72.516 0 76.527 0 77.84c0 .691.148 1.273.293 1.273.367 0 .367-.035 15.332-30.988 6.95-14.363 13.531-27.89 14.633-30.113 1.101-2.227 2.094-4.266 2.168-4.559.074-.328-2.461-2.844-6.508-6.379C22.281 3.864 19.082.95 18.785.621c-.844-1.023-2.094-.695-4.336 1.094zM15.7 43.64c-1.692 3.246-1.766 3.28-6.4 3.5-4.081.218-4.152.183-4.152-.582 0-.438-.148-1.024-.332-1.313-.222-.328-.074-.914.442-1.715l.808-1.238h3.676c2.024-.04 4.34-.184 5.149-.328.808-.149 1.507-.219 1.578-.184.074.035-.293.875-.77 1.86zm-3.09 5.832c-.294.765-1.067 2.37-1.692 3.574-1.027 2.043-1.137 2.113-1.395 1.277-.148-.511-.257-2.008-.296-3.355-.036-2.66-.11-2.625 2.98-2.809l.992-.035zm0 0"}),React__namespace.createElement("path",{d:"M15.55 10.39c-.66.473-.843.95-.843 2.153 0 1.422.11 1.64 1.102 2.039.992.402 1.25.367 2.39-.398 1.508-1.024 1.543-1.278.442-2.918-.957-1.422-1.914-1.676-3.09-.875zm2.098 1.313c.586 1.02.22 1.785-.882 1.785-.993 0-1.434-.984-.883-1.968.441-.801 1.285-.727 1.765.183zm0 0M38.602 18.594c0 .183-.22.363-.477.363-.219 0-.844 1.023-1.324 2.262-1.469 3.793-16.176 32.629-16.211 31.718 0-.472-.223-.8-.59-.8-.516 0-.59.289-.367 1.71.219 1.641.074 2.008-5.149 12.071-2.941 5.723-6.101 11.703-7.02 13.305-.956 1.68-1.69 3.5-1.765 4.265-.11 1.313.035 1.496 3.235 4.23 1.84 1.606 4.191 3.61 5.222 4.52 4.63 4.196 6.801 5.871 7.387 5.762.883-.145 14.523-14.328 14.559-15.129 0-.367-.66-5.906-1.47-12.324-1.398-10.938-2.722-23.734-2.573-24.973.109-.765-.442-4.633-.844-6.308-.332-1.313-.184-1.86 2.46-7.84 1.544-3.535 3.567-7.875 4.45-9.625.844-1.75 1.582-3.281 1.582-3.39 0-.11-.258-.18-.55-.18-.298 0-.555.144-.555.363zm-8.454 27.234c.403 2.55 1.211 8.676 1.801 13.598 1.14 9.043 2.461 19.07 2.832 21.62.219 1.278.07 1.532-2.316 4.157-4.156 4.629-8.567 9.188-10.074 10.356l-1.399 1.093-7.168-6.636c-6.617-6.051-7.168-6.672-6.765-7.403.222-.398 2.097-3.789 4.156-7.508 2.058-3.718 4.777-8.68 6.027-11.011 1.29-2.371 2.465-4.41 2.684-4.52.258-.148.332 3.535.258 11.375-.149 11.703-.11 11.739 1.066 11.485.148 0 .258-5.907.258-13.09V56.293l3.86-7.656c2.132-4.23 3.898-7.621 3.972-7.586.07.039.441 2.187.808 4.777zm0 0"}))),search:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 512 512"},React__namespace.createElement("path",{d:"M500.3 443.7l-119.7-119.7c27.22-40.41 40.65-90.9 33.46-144.7C401.8 87.79 326.8 13.32 235.2 1.723C99.01-15.51-15.51 99.01 1.724 235.2c11.6 91.64 86.08 166.7 177.6 178.9c53.8 7.189 104.3-6.236 144.7-33.46l119.7 119.7c15.62 15.62 40.95 15.62 56.57 0C515.9 484.7 515.9 459.3 500.3 443.7zM79.1 208c0-70.58 57.42-128 128-128s128 57.42 128 128c0 70.58-57.42 128-128 128S79.1 278.6 79.1 208z"})),switchToMarkdown:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 640 512"},React__namespace.createElement("path",{d:"M593.8 59.1H46.2C20.7 59.1 0 79.8 0 105.2v301.5c0 25.5 20.7 46.2 46.2 46.2h547.7c25.5 0 46.2-20.7 46.1-46.1V105.2c0-25.4-20.7-46.1-46.2-46.1zM338.5 360.6H277v-120l-61.5 76.9-61.5-76.9v120H92.3V151.4h61.5l61.5 76.9 61.5-76.9h61.5v209.2zm135.3 3.1L381.5 256H443V151.4h61.5V256H566z"})),gotoFullScreen:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 448 512"},React__namespace.createElement("path",{d:"M128 32H32C14.31 32 0 46.31 0 64v96c0 17.69 14.31 32 32 32s32-14.31 32-32V96h64c17.69 0 32-14.31 32-32S145.7 32 128 32zM416 32h-96c-17.69 0-32 14.31-32 32s14.31 32 32 32h64v64c0 17.69 14.31 32 32 32s32-14.31 32-32V64C448 46.31 433.7 32 416 32zM128 416H64v-64c0-17.69-14.31-32-32-32s-32 14.31-32 32v96c0 17.69 14.31 32 32 32h96c17.69 0 32-14.31 32-32S145.7 416 128 416zM416 320c-17.69 0-32 14.31-32 32v64h-64c-17.69 0-32 14.31-32 32s14.31 32 32 32h96c17.69 0 32-14.31 32-32v-96C448 334.3 433.7 320 416 320z"})),exitFullScreen:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 448 512"},React__namespace.createElement("path",{d:"M128 320H32c-17.69 0-32 14.31-32 32s14.31 32 32 32h64v64c0 17.69 14.31 32 32 32s32-14.31 32-32v-96C160 334.3 145.7 320 128 320zM416 320h-96c-17.69 0-32 14.31-32 32v96c0 17.69 14.31 32 32 32s32-14.31 32-32v-64h64c17.69 0 32-14.31 32-32S433.7 320 416 320zM320 192h96c17.69 0 32-14.31 32-32s-14.31-32-32-32h-64V64c0-17.69-14.31-32-32-32s-32 14.31-32 32v96C288 177.7 302.3 192 320 192zM128 32C110.3 32 96 46.31 96 64v64H32C14.31 128 0 142.3 0 160s14.31 32 32 32h96c17.69 0 32-14.31 32-32V64C160 46.31 145.7 32 128 32z"})),releaseNotes:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 512 512"},React__namespace.createElement("path",{d:"M0 219.2v212.5c0 14.25 11.62 26.25 26.5 27C75.32 461.2 180.2 471.3 240 511.9V245.2C181.4 205.5 79.99 194.8 29.84 192C13.59 191.1 0 203.6 0 219.2zM482.2 192c-50.09 2.848-151.3 13.47-209.1 53.09C272.1 245.2 272 245.3 272 245.5v266.5c60.04-40.39 164.7-50.76 213.5-53.28C500.4 457.9 512 445.9 512 431.7V219.2C512 203.6 498.4 191.1 482.2 192zM352 96c0-53-43-96-96-96S160 43 160 96s43 96 96 96S352 149 352 96z"})),rawMode:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 100 60"},React__namespace.createElement("path",{stroke:"var(--icon-fill-color)",strokeWidth:"4",d:"M20 10H10m10 0H10m0 0v40m0-40v40m0 0h10m-10 0h10M40 10H30m10 0H30m0 0v40m0-40v40m0 0h10m-10 0h10M60 10h10m-10 0h10m0 0v40m0-40v40m0 0H60m10 0H60M80 10h10m-10 0h10m0 0v40m0-40v40m0 0H80m10 0H80"})),parsedMode:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 576 512"},React__namespace.createElement("path",{d:"M574.1 280.4l-45.38-181.8c-5.875-23.63-21.62-44-43-55.75c-21.5-11.75-46.1-14.13-70.25-6.375l-15.25 5.125c-8.375 2.75-12.87 11.88-10 20.25l5 15.13c2.75 8.375 11.88 12.88 20.25 10.13l13.12-4.375c10.88-3.625 23-3.625 33.25 1.75c10.25 5.375 17.5 14.5 20.38 25.75l38.38 153.9c-22.12-6.875-49.75-12.5-81.13-12.5c-34.88 0-73.1 7-114.9 26.75H251.4C210.5 258.6 171.4 251.6 136.5 251.6c-31.38 0-59 5.625-81.12 12.5l38.38-153.9c2.875-11.25 10.12-20.38 20.5-25.75C124.4 79.12 136.5 79.12 147.4 82.74l13.12 4.375c8.375 2.75 17.5-1.75 20.25-10.13l5-15.13C188.6 53.49 184.1 44.37 175.6 41.62l-15.25-5.125c-23.13-7.75-48.75-5.375-70.13 6.375c-21.37 11.75-37.12 32.13-43 55.75L1.875 280.4C.6251 285.4 .0001 290.6 .0001 295.9v70.25C.0001 428.1 51.63 480 115.3 480h37.13c60.25 0 110.4-46 114.9-105.4l2.875-38.63h35.75l2.875 38.63C313.3 433.1 363.4 480 423.6 480h37.13c63.62 0 115.2-51 115.2-113.9V295.9C576 290.6 575.4 285.5 574.1 280.4zM203.4 369.7c-2 26-24.38 46.25-51 46.25H115.2C87 415.1 64 393.6 64 366.1v-37.5c18.12-6.5 43.38-13 72.62-13c23.88 0 47.25 4.375 69.88 13L203.4 369.7zM512 366.1c0 27.5-23 49.88-51.25 49.88h-37.13c-26.62 0-49-20.25-51-46.25l-3.125-41.13c22.62-8.625 46.13-13 70-13c29 0 54.38 6.5 72.5 13V366.1z"})),convertFile:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",viewBox:"0 110 700 340",xmlns:"http://www.w3.org/2000/svg"},React__namespace.createElement("path",{d:"m593.95 239.4v-1.5742c-0.85547-1.8828-2.043-3.6016-3.5-5.0742l-52.5-52.5c-1.4688-1.457-3.1875-2.6445-5.0742-3.5h-1.5742c-1.4727-0.49219-3.0039-0.78516-4.5508-0.875h-124.25c-4.6406 0-9.0938 1.8438-12.375 5.125s-5.125 7.7344-5.125 12.375v87.5h-70v-105.88-1.0508c-0.089844-1.5469-0.38281-3.0781-0.875-4.5508v-1.5742c-0.85547-1.8828-2.043-3.6016-3.5-5.0742l-52.5-52.5c-1.4727-1.457-3.1914-2.6445-5.0742-3.5h-1.5742c-1.7031-0.875-3.5352-1.4688-5.4258-1.75h-123.55c-4.6406 0-9.0938 1.8438-12.375 5.125s-5.125 7.7344-5.125 12.375v245c0 4.6406 1.8438 9.0938 5.125 12.375s7.7344 5.125 12.375 5.125h175c4.6406 0 9.0938-1.8438 12.375-5.125s5.125-7.7344 5.125-12.375v-52.5h70v122.5c0 4.6406 1.8438 9.0938 5.125 12.375s7.7344 5.125 12.375 5.125h175c4.6406 0 9.0938-1.8438 12.375-5.125s5.125-7.7344 5.125-12.375v-192.5-1.0508c-0.14453-1.5547-0.5-3.0859-1.0508-4.5508zm-313.95 110.6h-140v-210h87.5v35c0 4.6406 1.8438 9.0938 5.125 12.375s7.7344 5.125 12.375 5.125h35v87.5h-52.5c-6.2539 0-12.031 3.3359-15.156 8.75s-3.125 12.086 0 17.5 8.9023 8.75 15.156 8.75h52.5zm140 70v-105h27.824l-5.0742 5.0742c-3.7031 3.1719-5.9141 7.7461-6.1055 12.617-0.1875 4.8711 1.668 9.6016 5.1133 13.051 3.4492 3.4453 8.1797 5.3008 13.051 5.1133 4.8711-0.19141 9.4453-2.4023 12.617-6.1055l35-35c3.2578-3.2773 5.0898-7.7148 5.0898-12.336 0-4.625-1.832-9.0586-5.0898-12.34l-35-35c-4.5078-3.8555-10.66-5.1719-16.348-3.4883-5.6875 1.6797-10.137 6.1289-11.816 11.816-1.6836 5.6914-0.37109 11.844 3.4883 16.348l5.0742 5.0742h-27.824v-69.824h87.5v35c0 4.6406 1.8438 9.0938 5.125 12.375s7.7344 5.125 12.375 5.125h35v157.5z"})),cog:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 512 512"},React__namespace.createElement("path",{d:"M495.9 166.6C499.2 175.2 496.4 184.9 489.6 191.2L446.3 230.6C447.4 238.9 448 247.4 448 256C448 264.6 447.4 273.1 446.3 281.4L489.6 320.8C496.4 327.1 499.2 336.8 495.9 345.4C491.5 357.3 486.2 368.8 480.2 379.7L475.5 387.8C468.9 398.8 461.5 409.2 453.4 419.1C447.4 426.2 437.7 428.7 428.9 425.9L373.2 408.1C359.8 418.4 344.1 427 329.2 433.6L316.7 490.7C314.7 499.7 307.7 506.1 298.5 508.5C284.7 510.8 270.5 512 255.1 512C241.5 512 227.3 510.8 213.5 508.5C204.3 506.1 197.3 499.7 195.3 490.7L182.8 433.6C167 427 152.2 418.4 138.8 408.1L83.14 425.9C74.3 428.7 64.55 426.2 58.63 419.1C50.52 409.2 43.12 398.8 36.52 387.8L31.84 379.7C25.77 368.8 20.49 357.3 16.06 345.4C12.82 336.8 15.55 327.1 22.41 320.8L65.67 281.4C64.57 273.1 64 264.6 64 256C64 247.4 64.57 238.9 65.67 230.6L22.41 191.2C15.55 184.9 12.82 175.3 16.06 166.6C20.49 154.7 25.78 143.2 31.84 132.3L36.51 124.2C43.12 113.2 50.52 102.8 58.63 92.95C64.55 85.8 74.3 83.32 83.14 86.14L138.8 103.9C152.2 93.56 167 84.96 182.8 78.43L195.3 21.33C197.3 12.25 204.3 5.04 213.5 3.51C227.3 1.201 241.5 0 256 0C270.5 0 284.7 1.201 298.5 3.51C307.7 5.04 314.7 12.25 316.7 21.33L329.2 78.43C344.1 84.96 359.8 93.56 373.2 103.9L428.9 86.14C437.7 83.32 447.4 85.8 453.4 92.95C461.5 102.8 468.9 113.2 475.5 124.2L480.2 132.3C486.2 143.2 491.5 154.7 495.9 166.6V166.6zM256 336C300.2 336 336 300.2 336 255.1C336 211.8 300.2 175.1 256 175.1C211.8 175.1 176 211.8 176 255.1C176 300.2 211.8 336 256 336z"})),trayMode:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 640 512"},React__namespace.createElement("path",{d:"M618.1 97.67c-13.02-4.375-27.45 .1562-35.72 11.16L464 266.7l-118.4-157.8c-8.266-11.03-22.64-15.56-35.72-11.16C296.8 102 288 114.2 288 128v256c0 17.69 14.33 32 32 32s32-14.31 32-32v-160l86.41 115.2c12.06 16.12 39.13 16.12 51.19 0L576 224v160c0 17.69 14.33 32 32 32s32-14.31 32-32v-256C640 114.2 631.2 102 618.1 97.67zM224 96.01H32c-17.67 0-32 14.31-32 32s14.33 32 32 32h64v223.1c0 17.69 14.33 31.99 32 31.99s32-14.3 32-31.99V160h64c17.67 0 32-14.31 32-32S241.7 96.01 224 96.01z"})),copyElementLink:React__namespace.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 260 260","aria-hidden":"true",focusable:"false",role:"img"},React__namespace.createElement("path",{stroke:"var(--icon-fill-color)",fill:"none",strokeLinecap:"round",strokeWidth:"8",d:"M10 10h40m-40 0h40m0 0v40m0-40v40m0 0H10m40 0H10m0 0V10m0 40V10M210 10h40m-40 0h40m0 0v40m0-40v40m0 0h-40m40 0h-40m0 0V10m0 40V10M210 210h40m-40 0h40m0 0v40m0-40v40m0 0h-40m40 0h-40m0 0v-40m0 40v-40M10 210h40m-40 0h40m0 0v40m0-40v40m0 0H10m40 0H10m0 0v-40m0 40v-40M30 210V50m0 160V50M50 30h160M50 30h160M230 50v160m0-160v160M50 230h160m-160 0h160"}),React__namespace.createElement("path",{stroke:"var(--icon-fill-color)",fill:"none",strokeLinecap:"round",strokeWidth:"16",d:"M110 90c-6.67 1.67-30 3.11-40 10-10 6.89-20 21.37-20 31.37S60 153.56 70 160c10 6.44 33.33 8.33 40 10m0-80c-6.67 1.67-30 3.11-40 10-10 6.89-20 21.37-20 31.37S60 153.56 70 160c10 6.44 33.33 8.33 40 10M150 90c6.67 1.67 30 3.11 40 10 10 6.89 20 21.37 20 31.37s-10 22.19-20 28.63c-10 6.44-33.33 8.33-40 10m0-80c6.67 1.67 30 3.11 40 10 10 6.89 20 21.37 20 31.37s-10 22.19-20 28.63c-10 6.44-33.33 8.33-40 10"}),React__namespace.createElement("path",{stroke:"var(--icon-fill-color)",fill:"none",strokeLinecap:"round",strokeWidth:"16",d:"M89.868 130.198c13.36-.03 66.78-.17 80.13-.2m-80.13.2c13.36-.03 66.78-.17 80.13-.2"}))},FIRST_RUN='\nThe Excalidraw Obsidian plugin is much more than "just" a drawing tool. To help you get started here\'s a showcase of the key Excalidraw plugin features.\n\nIf you\'d like to learn more, please subscribe to my YouTube channel: [Visual PKM](https://www.youtube.com/channel/UCC0gns4a9fhVkGkngvSumAQ) where I regularly share videos about Obsidian-Excalidraw and about tools and techniques for Visual Personal Knowledge Management.\n\nThank you & Enjoy!\n\n
\n\n
\n',RELEASE_NOTES={Intro:'I want to help you keep up with all the updates. After installing each release, you\'ll be prompted with a summary of new features and fixes. You can disable these popup messages in plugin settings.\n\nI develop this plugin as a hobby, spending most of my free time doing this. If you\'d like to contribute to the on-going work, I have a simple membership scheme with Bronze, Silver and Gold tiers. Many of you have already bought me a coffee. THANK YOU! It really means a lot to me! If you find this plugin valuable, please consider supporting me.\n\n
\n',"1.7.7":`\n# New\n- Optimized for Obsidian 0.15.4\n- On a desktop, you can now use the META key when clicking on a link and it will open the link in a new popout Window.\n- ([#685](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/685)) Markdown embeds will now display correctly in Excalidraw even if they include photos and recursive markdown embeds. Unfortunately due to the limitations of Safari the inversion of colors on iPads in dark mode will not work well.\nSee an 18 second long demo video [here](https://user-images.githubusercontent.com/14358394/177213263-2a7ef1ca-0614-4190-8955-e830ca6b424b.mp4).\n\n\n# Fixed\n- ([#683](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/683)) Copy/Paste Markdown embeds to create another instance of the embed, thus you can reference different sections of the document in your drawing (something I broke in 1.7.6)\n- ([#684](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/684)) Transclusions incorrectly did not pick up subsections of a section. To understand this change, imagine for example the following document:\n${String.fromCharCode(96,96,96)}markdown\n# A\nabc\n# B\nxyz\n## b1\n123\n## b2\n456\n# C\n${String.fromCharCode(96,96,96)}\nWhen you transclude ${String.fromCharCode(96)}![[document#B]]${String.fromCharCode(96)} you expect the following result\n${String.fromCharCode(96,96,96)}markdown\nB\nxyz\n\nb1\n123\n\nb2\n456\n${String.fromCharCode(96,96,96)}\nUntil this fix you only got\n${String.fromCharCode(96,96,96)}markdown\nB\nxyz\n${String.fromCharCode(96,96,96)}`,"1.7.6":`\nThis release is the same as 1.7.5 except for two minor fixes\n- a fix for ExcaliBrain, becuase 1.7.5 broke ExcaliBrain.\n- I left out the release note from 1.7.5.\n\n# New\n- Deployed sidebar for libraries panel from excalidraw.com ([#5274](https://github.com/excalidraw/excalidraw/pull/5274)). You can dock the library to the right side depending on the screen real estate available (i.e. does not work on mobiles).\n\n# Fixed\n- When copying 2 identical images from one drawing to another, the second image got corrupted in the process ([#672]https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/672)).\n- When making a copy of an equation in a drawing and then without first closing/opening the file, immediately copying the new equation to another drawing, the equation did not get displayed until the file was closed and reopened.\n- Copying a markdown embed from one drawing to another, in the destination the markdown embed appeared without the section/block reference and without the width & height (i.e. these settings had to be done again)\n- Improved the parsing of section references in embeds. When you had ${String.fromCharCode(96)}&${String.fromCharCode(96)} in the section name in a markdown file, when embedding that markdown document into Excalidraw, the section reference did not work as expected ([#681 ](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/681)).\n- Improved the logic for autosave to better detect changes to the document, and to reduce too frequent export of ${String.fromCharCode(96)}.png${String.fromCharCode(96)} and/or ${String.fromCharCode(96)}.svg${String.fromCharCode(96)} files, when auto export is enabled in plugin settings.\n`,"1.7.5":`\n# New\n- Deployed sidebar for libraries panel from excalidraw.com ([#5274](https://github.com/excalidraw/excalidraw/pull/5274)). You can dock the library to the right side depending on the screen real estate available (i.e. does not work on mobiles).\n\n# Fixed\n- When copying 2 identical images from one drawing to another, the second image got corrupted in the process ([#672]https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/672)).\n- When making a copy of an equation in a drawing and then without first closing/opening the file, immediately copying the new equation to another drawing, the equation did not get displayed until the file was closed and reopened.\n- Copying a markdown embed from one drawing to another, in the destination the markdown embed appeared without the section/block reference and without the width & height (i.e. these settings had to be done again)\n- Improved the parsing of section references in embeds. When you had ${String.fromCharCode(96)}&${String.fromCharCode(96)} in the section name in a markdown file, when embedding that markdown document into Excalidraw, the section reference did not work as expected ([#681 ](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/681)).\n- Improved the logic for autosave to better detect changes to the document, and to reduce too frequent export of ${String.fromCharCode(96)}.png${String.fromCharCode(96)} and/or ${String.fromCharCode(96)}.svg${String.fromCharCode(96)} files, when auto export is enabled in plugin settings.\n`,"1.7.4":"\n- Obsidian 0.15.3 support dragging and dropping work panes between Obsidian windows.\n- Addressed Obsidian changes affecting the more-options menu.\n- Addressed incompatibility with Obsidian Mobile 1.2.2.\n","1.7.3":"\nObsidian 0.15.3 support for dragging and dropping work panes between Obsidian windows.\n","1.7.2":"\nDue to some of the changes to the code, I highly recommend restarting Obsidian after installing this update to Excalidraw.\n\n# Fixed\n- Stability improvements\n- Opening links in new panes and creating new drawings from the file explorer works properly again\n\n# New feature\n- Two new command palette actions:\n - Create a new drawing - IN A POPOUT WINDOW\n - Create a new drawing - IN A POPOUT WINDOW - and embed into active document\n![image|600](https://user-images.githubusercontent.com/14358394/175137800-88789f5d-f8e8-4371-a356-84f443aa6a50.png)\n- Added setting to prefer opening the link in the popout window or in the main workspace.\n![image|800](https://user-images.githubusercontent.com/14358394/175076326-1c8eee53-e512-4025-aedb-07881a732c69.png)\n","1.7.1":"\nSupport for Obsidian 0.15.0 popout windows. While there are no new features (apart from the popout window support) under the hood there were some major changes required to make this happen.\n","1.7.0":"\nThis is the first test version of Excalidraw Obsidian supporting Obsidian 0.15.0 popout windows. The current technical solution is not really sustainable, it's more of a working concept. I don't expect any real big issues with this version - on the contrary, this works much better with Obsidian 0.15.0 popout windows, but some of the features aren't working as expected in the Obsidian popouts yet. Also as a consequence of Obsidian 0.15.0 compatibility, multiple hover previews are no longer supported.\n","1.6.34":"\nWith 0.15.1 Obsidian is implementing some exciting, but significant changes to how windows are managed. I need to make some heavy/invasive changes to Excalidraw to adapt. The next version of the Excalidraw Plugin will require Obsidian 0.15.1 or newer. If you are not signed up for Obsidian Insider Builds, you will need to wait few weeks until the new Obsidian version will be made public.\n\n# Fixed\n- Error saving when the attachments folder exists but with a different letter case (i.e. ATTACHMENTS instead of attachments) [658](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/658). I added more error tolerance. As a general rule, however, I recommend treating file paths as case-sensitive as some platforms like iOS or LINUX have case-sensitive filenames, and synchronizing your Vault to these platforms will cause you headaches in the future.\n- Text detached from the container if you immediately clicked the text-align buttons on the properties pane while still editing the text in the container for the very first time. [#657](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/657).\n- Can't add text to the second container if the first container has text and the second container is centered around the first one. [#5300](https://github.com/excalidraw/excalidraw/issues/5300)\n","1.6.33":`\n# Fixed\n- Under some special circumstances when you embedded a drawing (guest) into another drawing (host), the host did not update when you modified the guest, until you closed Excalidraw completely and reopened the host. [#637](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/637)\n\n# New\n- ExcalidrawAutomate ${String.fromCharCode(96)}addLabelToLine${String.fromCharCode(96)} adds a text label to a line or arrow. Currently this function only works with simple straight 2-point (start & end) lines.\n${String.fromCharCode(96,96,96)}typescript\naddLabelToLine(lineId: string, label: string): string\n${String.fromCharCode(96,96,96)}\n- ExcalidrawAutomate ${String.fromCharCode(96)}ConnectObjects${String.fromCharCode(96)} now returns the ID of the arrow that was created.`,"1.6.32":"\n## Fixed\n- Filenames of embedded images and markdown documents did not get updated if the drawing was open in a work-pane while you changed the filename of the embedded file (image or markdown document) [632](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/632).\n- When you created a new text element and immediately dragged it, sometimes autosave interrupted the drag action and Excalidraw dropped the element you were dragging [630](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/630)\n- In some edge cases when you had the drawing open on your desktop and you also opened the same image on your tablet, Sync seemed to work in the background but the changes did not appear on the desktop until you closed and opened the drawing again. [629](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/629)\n- LaTeX support: Excalidraw must download a javascript library from one of the hosting sites for MathJax tex2svg. It seems that some people do not have access to the URL recommended in the first place by [MathJax](https://docs.mathjax.org/en/latest/web/start.html). If LaTeX formulas do not render correctly in Excalidraw, try changing the source server under Compatibility Settings in Excalidraw Plugin Settings. [628](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/628)","1.6.31":"\nMinor update:\n\n## Fixes\n- Color picker hotkeys were not working. They are working again [627](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/627)\n- I updated MathJax (LaTeX) to the newest (3.2.1) release.","1.6.30":"\n## Fixed\n- The load stencil library button stopped working after 1.6.29 due to an error in the core Excalidraw package. It is now fixed. [#625](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/625).\n- On iPad (probably other Obsidian mobile devices as well) after opening the command palette the positioning of the pointer was off. From now on, the pointer is automatically re-calibrated every 5 seconds.\n- I improved shared-vault collaboration sync. If the open file has not been saved for the last 5 minutes (i.e. you are not working on the drawing actively), and a newer remote version of the file is received via sync, then the remote file will simply overwrite the local file (i.e. the behavior of Excalidraw Obsidian prior to implementing Shared (Multiplayer) Vault Synchronization support in 1.6.29). This solution will support active collaboration when parties participating are actively editing the drawing, but also caters to the scenario when you open a drawing on one device (e.g. your desktop) and once you are finished editing you do not close the drawing, but simply put your PC to sleep... then later you edit the same drawing on your tablet. When you turn your desktop PC on the next time, the changes you've made on your tablet will be synchronized by Obsidian sync. In this case the changes from your tablet should be honored. If you have not edited the open drawing for more then 5 minutes (like in this scenario) there is no value in running the file comparison between the local version and the received one. This approach reduces the probability of running into sync conflicts.","1.6.29":"\n## New\n- I implemented sync support inspired by the new [Obsidian Multiplayer Sync](https://youtu.be/ZyCPhbd51eo) feature (available in insider build v0.14.10). \n - To manage expectations, this is not real-time collaboration like on Excalidraw.com. Synchronization is delayed by the frequency of the autosave timer (every 10 secs) and the speed of Obsidian sync. Also if a file has conflicting versions, Obsidian sync may delay the delivery of the changed file.\n - Even if you are not using multiplayer Obsidian Vaults, you may benefit from the improved synchronization, for example when using the freedraw tool on your tablet or phone, and in parallel editing the same drawing (e.g. typing text) on your desktop. I frequently do this in a mind-mapping scenario.\n - If the same Excalidraw sketch is open on multiple devices then Excalidraw will try to merge changes into the open drawing, thus parallel modifications on different devices are possible. If the same element is edited by multiple parties at the same time, then the foreign (received) version will be honored and the local changes lost. \n\n## Fixed:\n- Default embed width setting stopped working. [#622](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/622)\n- The link tooltip gets stuck on screen after Excalidraw closes [#621](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/621)\n- Layout error when using the Workspaces core plugin. [#28](https://github.com/zsviczian/excalibrain/issues/28)","1.6.28":'\n## New\n- When dropping a link from a DataView query into Excalidraw the link will honor your "New link format" preferences in Obsidian. It will add the "shortest path when possible", if that is your setting. If the link includes a block or section reference, then the link will automatically include an alias, such that only the filename is displayed (shortest path possible allowing) [#610](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/610)\n- If Excalidraw is in a Hover Editor and you open a link in another pane by CTRL+SHIFT+Click then the new page will open in the main workspace, and not in a split pane in the hover editor.\n\n## Fixed\n- New text elements get de-selected after auto-save [#609](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/609)\n- Update opacity of bound text when the opacity of the container is updated [#5142](https://github.com/excalidraw/excalidraw/pull/5142)\n- ExcalidrawAutomate: openFileInNewOrAdjacentLeaf() function. This also caused an error when clicking a link in Excalidraw in a hover window, when there were no leaves in the main workspace view.',"1.6.27":"\n## New Features\n- While these new features are benefitial for all Excalidraw Automation projects, the current changes are mainly in support of the [ExcaliBrain](https://youtu.be/O2s-h5VKCas) integration. See detailed [Release Notes](https://github.com/zsviczian/obsidian-excalidraw-plugin/releases/tag/1.6.27) on GitHub.\n","1.6.26":`\n## Fixed\n- Dragging multiple files onto the canvas will now correctly [#589](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/589)\n - add multiple links\n - or if you hold the CTRL/(SHIFT on Mac) while dropping the files, then adding multiple images\n- Dropped images and links were not selectable with the selection tool until the file was saved. This is now fixed.\n- Display the linked block/section on link-hover instead of the full page. [#597](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/597)\n- Hover preview without CTRL/CMD works again. Requires configuration in plugin settings. [#595](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/595)\n- If you embed the same markdown document into a drawing multiple times, you can now display different sections of the document in each embedded object. [#601](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/601).\n- If you make a copy of an equation and edit this copy, the original equation will remain unchanged [#593](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/593)\n\n## New Features\n- When you drag files from Dataview-results onto the canvas the obsidian:// urls will be converted into wiki links.[#599](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/599)\n- I added one more frontmatter key: ${String.fromCharCode(96)}excalidraw-linkbutton-opacity: ${String.fromCharCode(96)} This sets the opacity of the blue link-button in the top right corner of the element, overriding the respective setting in plugin settings. Valid values are numbers between 0 and 1, where 0 means the button is fully transparent.\n\n## New Excalidraw Automate Features\n- As part of building the new [ExcaliBrain](https://youtu.be/O2s-h5VKCas) plugin, I've added a number of integration features. See the GitHub [Release Notes](https://github.com/zsviczian/obsidian-excalidraw-plugin/releases/tag/1.6.26) for details.\n`,"1.6.25":`\n## Fixed\n- Pinch-zoom in view mode was broken ([#5001](https://github.com/excalidraw/excalidraw/pull/5001))\n- The add image button on iPad was not working ([#5038](https://github.com/excalidraw/excalidraw/pull/5038) & [#584](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/584))\n\n## New Features\n- If Excalidraw is open in a [hover-editor](https://github.com/nothingislost/obsidian-hover-editor) when opening a link in a new pane Excalidraw will now open the link in the main workspace and not by splitting the view inside the hover-editor. \n- Excalidraw ScriptEngine settings\n - Script Engine settings now render HTML descriptions\n - If the ${String.fromCharCode(96)}height${String.fromCharCode(96)} property of a text setting is set, the corresponding text input field will be rendered as a textArea with the specified height.\n`,"1.6.24":"\n## Fixed\n- Link fixes:\n - Shift+Click on an element link (i.e. a link attached to a rectangle, ellipse, etc) did not open the link in a new leaf.\n - Clicking a link and opening it in a new leaf will now make the new leaf active and focused after the click.\n- Pointer calibration:\n - Opening an Excalidraw drawing with the [hover-editor](https://github.com/nothingislost/obsidian-hover-editor) and dragging the editor to another location corrupted the calibration of the pointer in Excalidraw. Similarly, when rearranging workspace panes by dragging, Excalidraw lost pointer calibration.\n\n## New Features\n### From Excalidraw.com\n- Element locking: The lock and unlock action is in the context menu.\n\n### Plugin\n- Any element that has a link, ctrl/cmd+clicking anywhere on the object will trigger the link action. You no longer have to go to the link icon. ([#541](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/541#issuecomment-1075578365))\n","1.6.23":`\n## Fixed:\n- I have received some user feedback about cases where the text separated from the sticky note. This version comes with a cleanup algorithm that will try to automatically resolve these issues.\n- Autosave did not notice changes in a very obscure case, when you opened a drawing, resized an element, and without deselecting the element you immediately closed the drawing. ([565](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/565))\n- CTRL+Enter to create a task did not work in hover-editor when opened from Excalidraw. Now it does! Thanks @pjeby! ([567](https://github.com/zsviczian/obsidian-excalidraw-plugin/pull/567))\n\n## New Features\n- If you have the [Obsidian-Latex](https://github.com/xldenis/obsidian-latex) plugin installed, from now Excalidraw will also process the ${String.fromCharCode(96)}preambles.sty${String.fromCharCode(96)} file. ( [563](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/563))\n- I added a new setting ${String.fromCharCode(96)}Embed & Export >> If found, use the already exported image for preview${String.fromCharCode(96)}. This setting works in conjunction with the ${String.fromCharCode(96)}Auto-export SVG/PNG${String.fromCharCode(96)} settings. If an exported image that matches the file name of the drawing is available, use that image instead of generating a preview image on the fly. This will result in faster previews especially when you have many embedded objects in the drawing, however, it may happen that your latest changes are not displayed and that the image will not automatically match your Obsidian theme in case you have changed the Obsidian theme since the export was created. This setting only applies to embedding images into markdown documents. For a number of reasons, the same approach cannot be used to expedite the loading of drawings with many embedded objects. See release notes for a [demo video](https://github.com/zsviczian/obsidian-excalidraw-plugin/releases/tag/1.6.22).\n`,"1.6.22":'\n## Fixed:\n- "Create a new drawing - IN THE CURRENT ACTIVE PANE - and embed into active document" did not work as intended when an Excalidraw pane was already open. [#559](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/559)\n- [Obsidian-hover-editor](https://github.com/nothingislost/obsidian-hover-editor) related improvements [#555](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/555):\n - hovering triggered many hover preview windows in quick succession, and in some cases raised dozens of errors in the Developer Console\n - hover-editors were not visible in Excalidraw fullscreen mode\n\n## Minor new features:\n- Activating the eraser with key "e" will toggle the active tool and back. So for example if you are drawing a freedraw shape, you can press "e" to delete a few strokes, then press "e" again to continue drawing. On desktop PCs many styluses allow you to configure the pen button to trigger keypress "e". \n- New setting to enable penMode by default.\n- I increased the file size limit for images you paste into Excalidraw from 2MB to 20MB. You should however avoid very large images as they will impact the overall performance of the canvas. ([#557](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/557))\n',"1.6.21":`\nBefore I move on to implementing further features, I spent this week with further stabilizing and debugging the plugin. Hopefully this will result in a smoother, better experince for you all.\n\n## Fixed\n- Links in drawings (e.g. text elements or embedded images) were sometimes not updating when the source file was moved or renamed in your Vault. The issue happend when you had the drawing and the linked file open in panes next to each other. This has led to broken links. ([#546](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/546))\n- To remove complexity and potential error, I have hidden the autosave settings. From now, autosave is now always enabled. Excalidraw will attempt to save your drawing every 10 seconds, or if you are actively engaged in drawing a shape at that very moment (e.g. you are busy with a freedraw line), then autosave will save the drawing at the earliest next opportunity. I imlemented further triggers to save the drawing when there are changes in the drawing and you click outside the drawing canvas. There was a rare error involving text elements, that when happened blocked saving of the file. This error is now properly handeled. Also from now, you will receive a warning message if for any reason save encountered problems. \n- If you have two heading sections in your drawing, e.g. ${String.fromCharCode(96)}# Section abc${String.fromCharCode(96)} and ${String.fromCharCode(96)}# Section abc def${String.fromCharCode(96)}, then referencing ${String.fromCharCode(96)}[[#Section abc]]${String.fromCharCode(96)} in a link will highlight both text elements when clicking the link. These section references now work as expected. ([#530](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/530))`,"1.6.20":`\n
\n\n
\n\n## Fixed\n- ${String.fromCharCode(96)}ExcalidrawAutomate.create()${String.fromCharCode(96)} threw an error [539](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/539)\n\n## New Features\n### From excalidraw.com\n- Bind/unbind text to/from container [4935](https://github.com/excalidraw/excalidraw/pull/4935)\n\n### Plugin\nFrontmatter tags to customize image export at a file level [519](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/519). If these keys are present they will override the default excalidraw embed and export settings.\n- ${String.fromCharCode(96)}excalidraw-export-transparent: true${String.fromCharCode(96)}\n - true == Transparent / false == with background. \n- ${String.fromCharCode(96)}excalidraw-export-dark${String.fromCharCode(96)}\n - true == Dark mode / false == light mode.\n- ${String.fromCharCode(96)}excalidraw-export-svgpadding${String.fromCharCode(96)}\n - This only affects export to SVG. Specify the export padding for the image\n- ${String.fromCharCode(96)}excalidraw-export-pngscale${String.fromCharCode(96)}\n - This only affects export to PNG. Specify the export scale for the image. The typical range is between 0.5 and 5, but you can experiment with other values as well.\n`,"1.6.19":"\nThis is a minor update fixing left-handed mode on iOS, and deploying improvements to the new Excalidraw Eraser.\n","1.6.18":`\n
\n\n
\n\n## Fixed\n- Modifying properties of a text element in tray mode. [496](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/496)\n- Friendly page aliases with iframely should work more reliably now.\n- I further improved resilience of loading from a damaged Excalidraw.md file.\n\n## New Features\n### From excalidraw.com\n- Added Eraser [4887](https://github.com/excalidraw/excalidraw/pull/4887)\n\n### Plugin\n- New setting for default transcluded-text line-wrap length. This is the default value for "wrapAt" in ${String.fromCharCode(96)}![[file#^block]]{wrapAt}${String.fromCharCode(96)}. Wrapping text using this feature will insert linebreaks in the transcluded text. An alternative approach is to transclude text inside sticky notes, in which case Excalidraw will automatically take care of text wrapping depending on the sticky note's width. [228](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/228)\n- New command palette action to toggle fullscreen mode, so you can assign a hotkey.\n- I added basic support for left-handed users. Enable it in plugin settings under the "Display" section. Currently, only affects the position of the tray in tray-mode. [510](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/510)\n- More flexible filename settings. ⚠ Due to the change, current settings may behave slightly differently compared to before. ⚠ [470](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/470)\n`,"1.6.17":`\n
\n\n
\n\n## Fixed\n- Freedraw shape's background color was missing in the SVG export. [#443](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/443)\n- In rare cases, when you only changed the background color of the drawing or edited the dimensions of an embedded markdown document, or changed an existing LaTeX formula, and then moved to another document in the vault, these changes did not get saved. [#503](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/503)\n- I resolved an Excalidraw Automate glitch with word wrapping in containers. EA generated containers with fixed line breaks. The same error also affected the conversion of drawings from the "legacy" Excalidraw.com file format.\n- When you allow/disable autosave in settings, this change will immediately take effect for all open Excalidraw workspace leaves. Until now autosave was activated only after you closed and reopened the Excalidraw view. [#502](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/502)\n- When you create a text element containing a ${String.fromCharCode(96,96,96)}[[markdown link]]${String.fromCharCode(96,96,96)} in raw mode, the new link was parsed nonetheless, and sometimes the link disappeared, leaving only the parsed text without the actual link. Creating links in raw-mode now works correctly.\n\n## New Features\n- The most recent 5 custom colors from the canvas are now added as color options to the element stroke and element background palette. [#4843](https://github.com/excalidraw/excalidraw/pull/4843)\n- Vertical text alignment for text in sticky notes [#4852](https://github.com/excalidraw/excalidraw/pull/4852)\n- Markdown embeds into Excalidraw now receive default styling, including that of tables, blockquotes, and code blocks. I also added a new setting and corresponding frontmatter-key to set the border-color for the embedded markdown document. You can override plugin settings at the document level by adding ${String.fromCharCode(96,96,96)}excalidraw-border-color: steelblue${String.fromCharCode(96,96,96)} to the markdown document you want to embed into your drawing. Valid values are css-color-name|#HEXcolor|any-other-html-standard-format.\n- In Obsidian search, when the text you were searching for is found in an Excalidraw document, clicking the link in search-results will open the drawing with the matching text element selected and zoomed.\n- Excalidraw now supports linking to text elements on the canvas and linking to non-text objects. \n1) You can reference text headings just the same as markdown headings in a document\ni.e. you have a text element that includes a valid markdown heading:\n${String.fromCharCode(96,96,96)}markdown\n# My Heading\ndetails...\n${String.fromCharCode(96,96,96)}\nor \n${String.fromCharCode(96,96,96)}markdown\ntext element text\n# my reference\n${String.fromCharCode(96,96,96)}\nYou can reference these like this respectively: ${String.fromCharCode(96,96,96)}[[#My Heading|display alias]]${String.fromCharCode(96,96,96)} and ${String.fromCharCode(96,96,96)}[[#my reference|alias]]${String.fromCharCode(96,96,96)}\n\n![image](https://user-images.githubusercontent.com/14358394/156890231-5a23bcb3-40a4-4ad7-b366-74c328620159.png)\n\n2) You can also reference element ids similar to block references\n- Links take this form ${String.fromCharCode(96,96,96)}[[#^elementID|alias]]${String.fromCharCode(96,96,96)}\n- Linking is supported by a new action on the Obsidian Tools Panel\n![image](https://user-images.githubusercontent.com/14358394/156894011-6442c3d6-aaff-43a8-bd77-513e450484ba.png)\n\n[Release Notes on GitHub](https://github.com/zsviczian/obsidian-excalidraw-plugin/releases/tag/1.6.17)\n`,"1.6.16":'\n
\n\n
\n\n\n## Fixed\n- CMD+Drag from the Obsidian File Manager does not work on Mac. You can now use SHIFT+Drag to embed an image or markdown document into a scene. ([#468](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/468))\n- Excalidraw Compressed JSON is now cut to smaller chunks (64 characters per paragraph, instead of the earlier 1024 characters). This should address search performance issues. ([#484](https://github.com/zsviczian/obsidian-excalidraw-plugin/issues/484))\n\n## New Features\n- I added the Obsidian Tools Panel\n - Click the Obsidian button to access the panel.\n - The tools panel contains key plugin commands and user / downloaded Excalidraw scripts.\n - Drag the panel with the handle at the top. Single click on the top to collapse the panel.\n - On Mobile press and hold the drag handle before dragging, to avoid activating the Obsidian slide in menus.\n - On Mobile long touch individual buttons on the panel to access tooltips.\n - Reinstall Excalidraw scripts to get the icons.\n- If you hold down SHIFT while resizing a sticky note, the text size will scale instead of text wrapping. ([Excalidraw tweet](https://twitter.com/aakansha1216/status/1496116528890417155?s=20&t=taXjA6I9Nd0T-C0wYBsG5g))\n- SVG export now includes links ([#4791](https://github.com/excalidraw/excalidraw/pull/4791))\n- Added full screen mode for Obsidian Mobile\n- Release notes\n - disable popup in settings\n - access release notes via the command palette, or the button on the tools panel\n\n[Release Notes on GitHub](https://github.com/zsviczian/obsidian-excalidraw-plugin/releases/tag/1.6.16)\n\n[![support-membership](https://raw.githubusercontent.com/zsviczian/obsidian-excalidraw-plugin/master/images/support-tiers.jpg)](https://ko-fi.com/zsolt)\n'};class ReleaseNotes extends obsidian.Modal{constructor(A,e,t){super(A),this.plugin=e,this.version=t}onOpen(){var A;this.contentEl.classList.add("excalidraw-release"),this.containerEl.classList.add(".excalidraw-release"),this.titleEl.setText(`Welcome to Excalidraw ${null!==(A=this.version)&&void 0!==A?A:""}`),this.createForm()}async onClose(){this.contentEl.empty(),await this.plugin.loadSettings(),this.plugin.settings.previousRelease=PLUGIN_VERSION,await this.plugin.saveSettings()}async createForm(){let A=this.plugin.settings.previousRelease;A=this.version===A?"0":A;const e=this.version?Object.keys(RELEASE_NOTES).filter((e=>e>A)).map((A=>`# ${A}\n${RELEASE_NOTES[A]}`)).slice(0,10).join("\n\n---\n"):FIRST_RUN;await obsidian.MarkdownRenderer.renderMarkdown(e,this.contentEl,"",this.plugin),this.contentEl.createEl("p",{text:""},(A=>{A.style.textAlign="right",A.createEl("button",{text:"Close"}).onclick=()=>this.close()}))}}const dark='({scriptIconMap:A})))}setPreviewMode(A){this.setState((()=>({isPreviewMode:A})))}setFullscreen(A){this.setState((()=>({isFullscreen:A})))}setExcalidrawViewMode(A){this.setState((()=>({excalidrawViewMode:A})))}toggleVisibility(A){this.setTopCenter(A),this.setState((A=>({visible:!A.visible})))}setTheme(A){this.setState((e=>({theme:A})))}setTopCenter(A){this.setState((()=>({left:(this.containerRef.current.clientWidth-228-(A?0:232))/2+this.containerRef.current.parentElement.offsetLeft+(A?0:232),top:64+this.containerRef.current.parentElement.offsetTop})))}updatePosition(A=0,e=0){this.setState((()=>{const{offsetTop:t,offsetLeft:i,clientWidth:n,clientHeight:a}=this.containerRef.current.firstElementChild,s=t-A,r=i-e,{clientWidth:o,clientHeight:l,offsetTop:c,offsetLeft:d}=this.containerRef.current.parentElement;return this.previousHeight=l,this.previousWidth=o,this.onBottomEdge=s>=l-a+c,this.onRightEdge=r>=o-n+d,{top:s{A.preventDefault(),Math.abs(this.penDownX-this.pos3)>5||Math.abs(this.penDownY-this.pos4)>5||this.setState((A=>({minimized:!A.minimized})))},onPointerDown:A=>{const e=A=>{A.preventDefault(),this.pos1=this.pos3-A.clientX,this.pos2=this.pos4-A.clientY,this.pos3=A.clientX,this.pos4=A.clientY,this.updatePosition(this.pos2,this.pos1)},t=()=>{var A,i;null===(A=this.props.view.ownerDocument)||void 0===A||A.removeEventListener("pointerup",t),null===(i=this.props.view.ownerDocument)||void 0===i||i.removeEventListener("pointermove",e)};A.preventDefault(),this.penDownX=this.pos3=A.clientX,this.penDownY=this.pos4=A.clientY,this.props.view.ownerDocument.addEventListener("pointerup",t),this.props.view.ownerDocument.addEventListener("pointermove",e)}},React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 228 26"},React__namespace.createElement("path",{stroke:"var(--icon-fill-color)",strokeWidth:"2",d:"M40,7 h148 M40,13 h148 M40,19 h148"}))),React__namespace.createElement("div",{className:"Island App-menu__left scrollbar",style:{maxHeight:"350px","--padding":2,display:this.state.minimized?"none":"block"}},React__namespace.createElement("div",{className:"panelColumn"},React__namespace.createElement("fieldset",null,React__namespace.createElement("legend",null,"Utility actions"),React__namespace.createElement("div",{className:"buttonList buttonListIcon"},React__namespace.createElement(ActionButton,{key:"search",title:t("SEARCH"),action:()=>{search(this.props.view)},icon:ICONS.search,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"release-notes",title:t("READ_RELEASE_NOTES"),action:()=>{new ReleaseNotes(this.props.view.app,this.props.view.plugin,PLUGIN_VERSION).open()},icon:ICONS.releaseNotes,view:this.props.view}),null===this.state.isPreviewMode?React__namespace.createElement(ActionButton,{key:"convert",title:t("CONVERT_FILE"),action:()=>{this.props.view.convertExcalidrawToMD()},icon:ICONS.convertFile,view:this.props.view}):React__namespace.createElement(ActionButton,{key:"viewmode",title:this.state.isPreviewMode?t("PARSED"):t("RAW"),action:()=>{this.state.isPreviewMode?this.props.view.changeTextMode(TextMode.raw):this.props.view.changeTextMode(TextMode.parsed)},icon:this.state.isPreviewMode?ICONS.rawMode:ICONS.parsedMode,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"tray-mode",title:t("TRAY_MODE"),action:()=>{this.props.view.toggleTrayMode()},icon:ICONS.trayMode,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"fullscreen",title:this.state.isFullscreen?t("EXIT_FULLSCREEN"):t("GOTO_FULLSCREEN"),action:()=>{this.state.isFullscreen?this.props.view.exitFullscreen():this.props.view.gotoFullscreen()},icon:this.state.isFullscreen?ICONS.exitFullScreen:ICONS.gotoFullScreen,view:this.props.view}))),React__namespace.createElement("fieldset",null,React__namespace.createElement("legend",null,"Export actions"),React__namespace.createElement("div",{className:"buttonList buttonListIcon"},React__namespace.createElement(ActionButton,{key:"lib",title:t("DOWNLOAD_LIBRARY"),action:()=>{this.props.view.plugin.exportLibrary()},icon:ICONS.exportLibrary,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"svg",title:t("EXPORT_SVG"),action:()=>{this.props.view.saveSVG(),new obsidian.Notice(`File saved: ${getIMGFilename(this.props.view.file.path,"svg")}`)},icon:ICONS.exportSVG,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"png",title:t("EXPORT_PNG"),action:()=>{this.props.view.savePNG(),new obsidian.Notice(`File saved: ${getIMGFilename(this.props.view.file.path,"png")}`)},icon:ICONS.exportPNG,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"excalidraw",title:t("EXPORT_EXCALIDRAW"),action:()=>{this.props.view.exportExcalidraw()},icon:ICONS.exportExcalidraw,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"md",title:t("OPEN_AS_MD"),action:()=>{this.props.view.openAsMarkdown()},icon:ICONS.switchToMarkdown,view:this.props.view}))),React__namespace.createElement("fieldset",null,React__namespace.createElement("legend",null,"Insert actions"),React__namespace.createElement("div",{className:"buttonList buttonListIcon"},React__namespace.createElement(ActionButton,{key:"image",title:t("INSERT_IMAGE"),action:()=>{this.props.centerPointer(),this.props.view.plugin.insertImageDialog.start(this.props.view)},icon:ICONS.insertImage,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"insertMD",title:t("INSERT_MD"),action:()=>{this.props.centerPointer(),this.props.view.plugin.insertMDDialog.start(this.props.view)},icon:ICONS.insertMD,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"latex",title:t("INSERT_LATEX"),action:()=>{this.props.centerPointer(),insertLaTeXToView(this.props.view)},icon:ICONS.insertLaTeX,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"link",title:t("INSERT_LINK"),action:()=>{this.props.centerPointer(),this.props.view.plugin.insertLinkDialog.start(this.props.view.file.path,this.props.view.addText)},icon:ICONS.insertLink,view:this.props.view}),React__namespace.createElement(ActionButton,{key:"link-to-element",title:t("INSERT_LINK_TO_ELEMENT"),action:()=>{this.props.view.copyLinkToSelectedElementToClipboard()},icon:ICONS.copyElementLink,view:this.props.view}))),this.renderScriptButtons(!1),this.renderScriptButtons(!0)))))}renderScriptButtons(A){if(0===Object.keys(this.state.scriptIconMap).length)return"";const e=`${this.props.view.plugin.settings.scriptFolderPath}/Downloaded/`,t=t=>A?t.startsWith(e):!t.startsWith(e);return 0===Object.keys(this.state.scriptIconMap).filter((A=>t(A))).length?"":React__namespace.createElement("fieldset",null,React__namespace.createElement("legend",null,A?"Downloaded":"User"," Scripts"),React__namespace.createElement("div",{className:"buttonList buttonListIcon"},Object.keys(this.state.scriptIconMap).filter((A=>t(A))).sort().map((e=>React__namespace.createElement(ActionButton,{key:e,title:A?this.state.scriptIconMap[e].name.replace("Downloaded/",""):this.state.scriptIconMap[e].name,action:async()=>{const A=this.props.view.app.vault.getAbstractFileByPath(e);A&&A instanceof obsidian.TFile&&this.props.view.plugin.scriptEngine.executeScript(this.props.view,await this.props.view.plugin.app.vault.read(A),this.props.view.plugin.scriptEngine.getScriptName(A))},icon:this.state.scriptIconMap[e].svgString?React__namespace.createElement("img",{src:`data:image/svg+xml,${encodeURIComponent("dark"===this.state.theme?this.state.scriptIconMap[e].svgString.replace("e.filter((e=>{if(t&&e.type!==t)return!1;const[i,n,a,s]=rotatedDimensions(e);return i<=A.x&&i+a>=A.x&&n<=A.y&&n+s>=A.y})),getTextElementAtPointer=(A,e)=>{const t=e.excalidrawAPI;if(!t)return{id:null,text:null};const i=getElementsAtPointer(A,t.getSceneElements(),"text");if(0==i.length)return{id:null,text:null};if(1===i.length)return{id:i[0].id,text:i[0].text};const n=i.filter((A=>{const t=e.textMode===TextMode.parsed?e.excalidrawData.getRawText(A.id):A.text;return!!t&&(!!t.match(REG_LINKINDEX_HYPERLINK)||!!REGEX_LINK.getRes(t).next().value)}));return 0==n.length?{id:i[0].id,text:i[0].text}:{id:n[0].id,text:n[0].text}},getImageElementAtPointer=(A,e)=>{const t=e.excalidrawAPI;if(!t)return;const i=getElementsAtPointer(A,t.getSceneElements(),"image");return 0===i.length?{id:null,fileId:null}:i.length>=1?{id:i[0].id,fileId:i[0].fileId}:void 0},getElementWithLinkAtPointer=(A,e)=>{const t=e.excalidrawAPI;if(!t)return;const i=getElementsAtPointer(A,t.getSceneElements()).filter((A=>A.link));return 0===i.length?{id:null,text:null}:i.length>=1?{id:i[0].id,text:i[0].link}:void 0};var TextMode;!function(A){A[A.parsed=0]="parsed",A[A.raw=1]="raw"}(TextMode||(TextMode={}));const addFiles=async(A,e,t)=>{if(!A||0===A.length||!e)return;const i=e.excalidrawAPI;if(!i)return;if(0===(A=A.filter((A=>A&&A.size&&A.size.height>0&&A.size.width>0))).length)return;const n=scaleLoadedImage(e.getScene(),A);void 0===t&&(t=n.scene.appState.theme),n.dirty&&e.updateScene({elements:n.scene.elements,appState:n.scene.appState,commitToHistory:!1});for(const i of A)if(e.excalidrawData.hasFile(i.id)&&e.excalidrawData.getFile(i.id).setImage(i.dataURL,i.mimeType,i.size,t,i.hasSVGwithBitmap),e.excalidrawData.hasEquation(i.id)){const A=e.excalidrawData.getEquation(i.id).latex;e.excalidrawData.setEquation(i.id,{latex:A,isLoaded:!0})}i.addFiles(A)},warningUnknowSeriousError=()=>{new obsidian.Notice("WARNING: Excalidraw ran into an unknown problem!\n\nThere is a risk that your most recent changes cannot be saved.\n\nTo be on the safe side...\n1) Please select your drawing using CTRL/CMD+A and make a copy with CTRL/CMD+C.\n2) Then create an empty drawing in a new pane by CTRL/CMD+clicking the Excalidraw ribbon button,\n3) and paste your work to the new document with CTRL/CMD+V.",6e4)};class ExcalidrawView extends obsidian.TextFileView{constructor(A,e){super(A),this.getScene=null,this.addElements=null,this.getSelectedTextElement=null,this.getSelectedImageElement=null,this.getSelectedElementWithLink=null,this.addText=null,this.refresh=null,this.excalidrawRef=null,this.excalidrawAPI=null,this.excalidrawWrapperRef=null,this.toolsPanelRef=null,this.linksAlwaysOpenInANewPane=!1,this.lastSaveTimestamp=0,this.metaKeyDown=!1,this.ctrlKeyDown=!1,this.shiftKeyDown=!1,this.altKeyDown=!1,this.semaphores={viewunload:!1,scriptsReady:!1,justLoaded:!1,preventAutozoom:!1,autosaving:!1,dirty:null,preventReload:!1,isEditingText:!1,saving:!1,forceSaving:!1,hoverSleep:!1},this.autosaveTimer=null,this.textMode=TextMode.raw,this.compatibilityMode=!1,this.isEditingTextResetTimer=null,this.id=this.leaf.id,this.getHookServer=()=>{var A;return null!==(A=this.hookServer)&&void 0!==A?A:this.plugin.ea},this.preventReloadResetTimer=null,this.fullscreenModalObserver=null,this.offsetLeft=0,this.offsetTop=0,this.isLoaded=!1,this.activeLoader=null,this.nextLoader=null,this.initialContainerSizeUpdate=!1,this.previousSceneVersion=0,this.previousBackgroundColor="",this.plugin=e,this.excalidrawData=new ExcalidrawData(e),this.hookServer=e.ea}setHookServer(A){this.hookServer=A||this.plugin.ea}preventAutozoom(){this.semaphores.preventAutozoom=!0,setTimeout((()=>this.semaphores.preventAutozoom=!1),2e3)}saveExcalidraw(A){if(!A){if(!this.getScene)return!1;A=this.getScene()}const e=`${this.file.path.substring(0,this.file.path.lastIndexOf(".md"))}.excalidraw`,t=this.app.vault.getAbstractFileByPath(obsidian.normalizePath(e));t&&t instanceof obsidian.TFile?this.app.vault.modify(t,JSON.stringify(A,null,"\t")):this.app.vault.create(e,JSON.stringify(A,null,"\t"))}async exportExcalidraw(){this.getScene&&this.file&&(this.app.isMobile?new Prompt(this.app,"Please provide filename",this.file.basename,"filename, leave blank to cancel action").openAndGetValue((async A=>{if(!A)return;A=`${A}.excalidraw`;const e=splitFolderAndFilename(this.file.path).folderpath;await checkAndCreateFolder(this.app.vault,e);const t=getNewUniqueFilepath(this.app.vault,A,e);this.app.vault.create(t,JSON.stringify(this.getScene(),null,"\t")),new obsidian.Notice(`Exported to ${t}`,6e3)})):download("data:text/plain;charset=utf-8",encodeURIComponent(JSON.stringify(this.getScene(),null,"\t")),`${this.file.basename}.excalidraw`))}async svg(A){const e={withBackground:getWithBackground(this.plugin,this.file),withTheme:!0};return await getSVG(Object.assign(Object.assign({},A),{appState:Object.assign(Object.assign({},A.appState),{theme:getExportTheme(this.plugin,this.file,A.appState.theme)})}),e,getSVGPadding(this.plugin,this.file))}async saveSVG(A){if(!A){if(!this.getScene)return!1;A=this.getScene()}const e=getIMGFilename(this.file.path,"svg"),t=this.app.vault.getAbstractFileByPath(obsidian.normalizePath(e)),i=await this.svg(A);if(!i)return;const n=(new XMLSerializer).serializeToString(embedFontsInSVG(i,this.plugin));t&&t instanceof obsidian.TFile?await this.app.vault.modify(t,n):await this.app.vault.create(e,n)}async png(A){const e={withBackground:getWithBackground(this.plugin,this.file),withTheme:!0};return await getPNG(Object.assign(Object.assign({},A),{appState:Object.assign(Object.assign({},A.appState),{theme:getExportTheme(this.plugin,this.file,A.appState.theme)})}),e,getPNGScale(this.plugin,this.file))}async savePNG(A){if(!A){if(!this.getScene)return!1;A=this.getScene()}const e=getIMGFilename(this.file.path,"png"),t=this.app.vault.getAbstractFileByPath(obsidian.normalizePath(e)),i=await this.png(A);i&&(t&&t instanceof obsidian.TFile?await this.app.vault.modifyBinary(t,await i.arrayBuffer()):await this.app.vault.createBinary(e,await i.arrayBuffer()))}async save(A=!0,e=!1){if(!this.semaphores.saving)if(this.semaphores.saving=!0,this.getScene&&this.excalidrawAPI&&this.isLoaded&&this.file&&this.app.vault.getAbstractFileByPath(this.file.path)){try{const t=Boolean(null!==this.semaphores.dirty&&this.semaphores.dirty||this.semaphores.autosaving||e),i=this.getScene();if(this.compatibilityMode?await this.excalidrawData.syncElements(i):await this.excalidrawData.syncElements(i,this.excalidrawAPI.getAppState().selectedElementIds)&&await this.loadDrawing(!1,this.excalidrawAPI.getSceneElementsIncludingDeleted().filter((A=>A.isDeleted))),t&&(this.preventReloadResetTimer&&(clearTimeout(this.preventReloadResetTimer),this.preventReloadResetTimer=null),this.semaphores.preventReload=A,await super.save(),this.lastSaveTimestamp=this.file.stat.mtime,this.clearDirty(),A)){const A=this;this.preventReloadResetTimer=setTimeout((()=>A.semaphores.preventReload=!1),2e3)}this.semaphores.autosaving||this.semaphores.viewunload||(this.plugin.settings.autoexportSVG&&await this.saveSVG(),this.plugin.settings.autoexportPNG&&await this.savePNG(),!this.compatibilityMode&&this.plugin.settings.autoexportExcalidraw&&this.saveExcalidraw())}catch(A){errorlog({where:"ExcalidrawView.save",fn:this.save,error:A}),warningUnknowSeriousError()}this.semaphores.saving=!1}else this.semaphores.saving=!1}getViewData(){if(!this.getScene)return this.data;if(!this.excalidrawData.loaded)return this.data;const A=this.getScene();if(!this.compatibilityMode){let A=this.data.search(/(^%%\n)?# Text Elements\n/m);if(-1==A&&(A=this.data.search(/(%%\n)?# Drawing\n/)),-1==A)return this.data;let e=this.data.substring(0,A).replace(/excalidraw-plugin:\s.*\n/,"excalidraw-plugin: "+(this.textMode===TextMode.raw?"raw\n":"parsed\n"));const t=/(^---[\w\W]*?---\n)(!\[\[.*?]]\n(%%\n)?)/m;e.match(t)&&(e=e.replace(t,"$1")),this.excalidrawData.disableCompression||(this.excalidrawData.disableCompression=this.isEditedAsMarkdownInOtherView());const i=e+this.excalidrawData.generateMD(this.excalidrawAPI.getSceneElementsIncludingDeleted().filter((A=>A.isDeleted)));return this.excalidrawData.disableCompression=!1,i}return this.compatibilityMode?JSON.stringify(A,null,"\t"):this.data}addFullscreenchangeEvent(){this.contentEl.onfullscreenchange=()=>{this.plugin.settings.zoomToFitOnResize&&this.zoomToFit(),this.isFullscreen()||(this.clearFullscreenObserver(),this.contentEl.removeAttribute("style")),this.toolsPanelRef&&this.toolsPanelRef.current&&this.toolsPanelRef.current.setFullscreen(this.isFullscreen())}}gotoFullscreen(){var A;if(this.excalidrawWrapperRef){if(this.toolsPanelRef&&this.toolsPanelRef.current&&this.toolsPanelRef.current.setFullscreen(!0),this.app.isMobile){const A=document.createElement("style");A.id="excalidraw-full-screen",A.textContent="\n .workspace-leaf-content .view-content {\n padding: 0px !important;\n }\n .view-header {\n height: 1px !important;\n }\n .status-bar {\n display: none !important;\n }";const e=document.getElementById(A.id);return e&&document.head.removeChild(e),void document.head.appendChild(A)}this.contentEl.requestFullscreen(),null===(A=this.excalidrawWrapperRef.current.firstElementChild)||void 0===A||A.focus(),this.contentEl.setAttribute("style","padding:0px;margin:0px;"),this.fullscreenModalObserver=new MutationObserver((A=>{if(1!==A.length)return;if(!A[0].addedNodes||1!==A[0].addedNodes.length)return;const e=A[0].addedNodes[0];if(e.nodeType!==Node.ELEMENT_NODE)return;const t=e;t.classList.contains("modal-container")&&(this.contentEl.appendChild(t),t.querySelector("input").focus())})),this.fullscreenModalObserver.observe(this.ownerDocument.body,{childList:!0,subtree:!1})}}clearFullscreenObserver(){this.fullscreenModalObserver&&(this.fullscreenModalObserver.disconnect(),this.fullscreenModalObserver=null)}isFullscreen(){return this.ownerDocument.fullscreenEnabled&&this.ownerDocument.fullscreenElement===this.contentEl}exitFullscreen(){if(this.toolsPanelRef&&this.toolsPanelRef.current&&this.toolsPanelRef.current.setFullscreen(!1),this.app.isMobile){const A=document.getElementById("excalidraw-full-screen");A&&document.head.removeChild(A)}else this.ownerDocument.exitFullscreen()}async handleLinkClick(A,e){var i,n,a,s;const r=this.ownerDocument.body.querySelector("body>div.excalidraw-tooltip,div.excalidraw-tooltip--visible");r&&this.ownerDocument.body.removeChild(r);const o=this.getSelectedTextElement(),l=(null==o?void 0:o.id)?null:this.getSelectedImageElement(),c=(null==l?void 0:l.id)||(null==o?void 0:o.id)?null:this.getSelectedElementWithLink();let d=null,h=null,g=null;if((null==o?void 0:o.id)||(null==c?void 0:c.id)){if(g=null!==(i=null==c?void 0:c.text)&&void 0!==i?i:this.textMode===TextMode.parsed?this.excalidrawData.getRawText(o.id):o.text,!g)return;if(g=g.replaceAll("\n",""),this.getHookServer().onLinkClickHook){const A=null!==(n=o.id)&&void 0!==n?n:c.id,t=this.excalidrawAPI.getSceneElements().filter((e=>e.id===A))[0];try{if(!this.getHookServer().onLinkClickHook(t,g,e,this,this.getHookServer()))return}catch(A){errorlog({where:"ExcalidrawView.handleLinkClick selectedText.id!==null",fn:this.getHookServer().onLinkClickHook,error:A})}}if(g.match(REG_LINKINDEX_HYPERLINK))return void window.open(g,"_blank");const a=REGEX_LINK.getRes(g).next();if(!a.value){const A=g.matchAll(/#([\p{Letter}\p{Emoji_Presentation}\p{Number}\/_-]+)/gu).next();if(!A.value||A.value.length<2)return;const e=this.app.workspace.getLeavesOfType("search");if(0==e.length)return;return e[0].view.setQuery(`tag:${A.value[1]}`),this.app.workspace.revealLeaf(e[0]),void(this.isFullscreen()&&this.exitFullscreen())}if(g=REGEX_LINK.getLink(a),g.match(REG_LINKINDEX_HYPERLINK))return void window.open(g,"_blank");if(g.search("#")>-1){const A=getLinkParts(g,this.file);h=`#${A.isBlockRef?"^":""}${A.ref}`,g=A.path}if(g.match(REG_LINKINDEX_INVALIDCHARS))return void new obsidian.Notice(t("FILENAME_INVALID_CHARS"),4e3);d=A.app.metadataCache.getFirstLinkpathDest(g,A.file.path)}if(null==l?void 0:l.id){if(this.excalidrawData.hasEquation(l.fileId)){const A=this.excalidrawData.getEquation(l.fileId).latex;return void new Prompt(this.app,t("ENTER_LATEX"),A,"").openAndGetValue((async e=>{e&&e!==A&&(this.excalidrawData.setEquation(l.fileId,{latex:e,isLoaded:!1}),await this.save(!1),await updateEquation(e,l.fileId,this,addFiles,this.plugin),this.setDirty(1))}))}if(await this.save(!1),this.excalidrawData.hasFile(l.fileId)){if(e.altKey){const A=this.excalidrawData.getFile(l.fileId);if("md"===A.file.extension&&!this.plugin.isExcalidrawFile(A.file))return void new Prompt(this.app,"Customize the link",A.linkParts.original,"","Do not add [[square brackets]] around the filename!
Follow this format when editing your link:
filename#^blockref|WIDTHxMAXHEIGHT").openAndGetValue((async e=>{e&&A.linkParts.original!==e&&(A.resetImage(this.file.path,e),await this.save(!1),await this.loadSceneFiles(),this.setDirty(2))}))}g=this.excalidrawData.getFile(l.fileId).file.path,d=this.excalidrawData.getFile(l.fileId).file}}if(g){if(this.getHookServer().onLinkClickHook){const A=null!==(s=null!==(a=l.id)&&void 0!==a?a:o.id)&&void 0!==s?s:c.id,t=this.excalidrawAPI.getSceneElements().filter((e=>e.id===A))[0];try{if(!this.getHookServer().onLinkClickHook(t,g,e,this,this.getHookServer()))return}catch(A){errorlog({where:"ExcalidrawView.handleLinkClick selectedText.id===null",fn:this.getHookServer().onLinkClickHook,error:A})}}try{if(e.shiftKey&&this.isFullscreen()&&this.exitFullscreen(),!d)return void new NewFileActions(this.plugin,g,e.shiftKey,!app.isMobile&&e.metaKey,A).open();const t=!app.isMobile&&(e.metaKey&&this.linksAlwaysOpenInANewPane||e.metaKey)?app.workspace.openPopoutLeaf():e.shiftKey||this.linksAlwaysOpenInANewPane?getNewOrAdjacentLeaf(this.plugin,A.leaf):A.leaf;await t.openFile(d,h?{active:!1,eState:{subpath:h}}:void 0)}catch(A){new obsidian.Notice(A,4e3)}}else new obsidian.Notice(t("LINK_BUTTON_CLICK_NO_TEXT"),2e4)}onResize(){var A,e;const t=this.excalidrawAPI;this.plugin.settings.zoomToFitOnResize&&this.excalidrawRef&&!this.semaphores.isEditingText&&t&&"text"!==(null===(e=null===(A=t.getAppState())||void 0===A?void 0:A.editingElement)||void 0===e?void 0:e.type)&&this.zoomToFit(!1)}getSceneVersion(A){return this.excalidrawGetSceneVersion||(this.excalidrawGetSceneVersion=this.plugin.getPackage(this.ownerWindow).excalidrawLib.getSceneVersion),this.excalidrawGetSceneVersion(A.filter((A=>!A.isDeleted)))}onload(){const A=Boolean(void 0===this.containerEl.onWindowMigrated);app.isMobile||A||this.containerEl.onWindowMigrated((()=>this.leaf.rebuildView()));const e=app.isMobile?document:this.containerEl.ownerDocument;this.ownerDocument=e,this.ownerWindow=this.ownerDocument.defaultView,this.plugin.getPackage(this.ownerWindow),this.semaphores.scriptsReady=!0,this.addAction("ScriptEngine",t("INSTALL_SCRIPT_BUTTON"),(()=>{new ScriptInstallPrompt(this.plugin).open()})),this.diskIcon=this.addAction("disk",t("FORCE_SAVE"),(async()=>{this.semaphores.autosaving||(this.semaphores.forceSaving=!0,await this.save(!1,!0),this.plugin.triggerEmbedUpdates(),this.loadSceneFiles(),this.semaphores.forceSaving=!1,new obsidian.Notice("Save successful",1e3))})),this.textIsRaw_Element=this.addAction("presentation",t("RAW"),(()=>this.changeTextMode(TextMode.parsed))),this.textIsParsed_Element=this.addAction("quote-glyph",t("PARSED"),(()=>this.changeTextMode(TextMode.raw))),this.addAction("link",t("OPEN_LINK"),(A=>this.handleLinkClick(this,A))),this.app.isMobile||this.addAction("fullscreen","Press ESC to exit fullscreen mode",(()=>this.gotoFullscreen()));const i=this;this.app.workspace.onLayoutReady((async()=>{i.contentEl.addClass("excalidraw-view"),await i.addSlidingPanesListner(),i.addParentMoveObserver(),i.onKeyUp=A=>{i.ctrlKeyDown=A[CTRL_OR_CMD],i.shiftKeyDown=A.shiftKey,i.altKeyDown=A.altKey,i.metaKeyDown=A.metaKey},i.onKeyDown=A=>{this.ctrlKeyDown=A[CTRL_OR_CMD],this.shiftKeyDown=A.shiftKey,this.altKeyDown=A.altKey,this.metaKeyDown=A.metaKey},i.ownerWindow.addEventListener("keydown",i.onKeyDown,!1),i.ownerWindow.addEventListener("keyup",i.onKeyUp,!1)})),this.setupAutosaveTimer()}async addSlidingPanesListner(){const A=this;this.slidingPanesListner=()=>{A.refresh&&A.refresh()};let e=this.app.workspace.rootSplit;for(;!e;)await sleep(50),e=this.app.workspace.rootSplit;e.containerEl.addEventListener("scroll",this.slidingPanesListner)}removeSlidingPanesListner(){var A;this.slidingPanesListner&&(null===(A=this.app.workspace.rootSplit.containerEl)||void 0===A||A.removeEventListener("scroll",this.slidingPanesListner))}addParentMoveObserver(){var A;const e=null!==(A=getParentOfClass(this.containerEl,"popover"))&&void 0!==A?A:getParentOfClass(this.containerEl,"workspace-leaf");if(!e)return;const t=e.classList.contains("popover");this.offsetLeft=e.offsetLeft,this.offsetTop=e.offsetTop;const i=this;this.parentMoveObserver=new MutationObserver((async A=>{const e=A[0].target;if(!(e instanceof HTMLElement))return;const{offsetLeft:t,offsetTop:n}=e;t===i.offsetLeft&&n==i.offsetTop||(i.refresh&&i.refresh(),i.offsetLeft=t,i.offsetTop=n)})),this.parentMoveObserver.observe(e,{attributeOldValue:!0,attributeFilter:t?["data-x","data-y"]:["class","style"]})}removeParentMoveObserver(){this.parentMoveObserver&&this.parentMoveObserver.disconnect()}setTheme(A){const e=this.excalidrawAPI;if(!this.excalidrawRef||!e)return;if(this.file&&hasExportTheme(this.plugin,this.file))return;const t=e.getAppState();this.excalidrawData.scene.theme=A,this.updateScene({appState:Object.assign(Object.assign({},t),{theme:A}),commitToHistory:!1})}async changeTextMode(A,e=!0){if(this.textMode=A,A===TextMode.parsed?(this.textIsRaw_Element.hide(),this.textIsParsed_Element.show()):(this.textIsRaw_Element.show(),this.textIsParsed_Element.hide()),this.toolsPanelRef&&this.toolsPanelRef.current&&this.toolsPanelRef.current.setPreviewMode(A===TextMode.parsed),e){await this.save(!1,!0),this.updateContainerSize();const A=this.excalidrawAPI;if(!A)return;A.history.clear()}}setupAutosaveTimer(){const A=async()=>{var e;const t=this.excalidrawAPI;if(!t)return void warningUnknowSeriousError();const i=t.getAppState(),n=null!==i.editingElement;this.refresh(),this.isLoaded&&this.semaphores.dirty&&this.semaphores.dirty==(null===(e=this.file)||void 0===e?void 0:e.path)&&this.plugin.settings.autosave&&!this.semaphores.forceSaving&&!n&&null===i.draggingElement?(this.autosaveTimer=null,this.semaphores.autosaving=!0,this.excalidrawRef&&await this.save(),this.semaphores.autosaving=!1,this.autosaveTimer=setTimeout(A,this.plugin.settings.autosaveInterval)):this.autosaveTimer=setTimeout(A,this.isLoaded&&this.plugin.activeExcalidrawView===this&&this.semaphores.dirty?1e3:this.plugin.settings.autosaveInterval)};this.autosaveTimer&&(clearTimeout(this.autosaveTimer),this.autosaveTimer=null),this.plugin.settings.autosave&&(this.autosaveTimer=setTimeout(A,this.plugin.settings.autosaveInterval))}onunload(){var A,e,t,i,n,a;if(this.semaphores.viewunload=!0,null===(A=this.ownerWindow)||void 0===A||A.removeEventListener("keydown",this.onKeyDown,!1),null===(e=this.ownerWindow)||void 0===e||e.removeEventListener("keyup",this.onKeyUp,!1),this.getHookServer().onViewUnloadHook)try{this.getHookServer().onViewUnloadHook(this)}catch(A){errorlog({where:"ExcalidrawView.onunload",fn:this.getHookServer().onViewUnloadHook,error:A})}const s=null===(i=null===(t=this.containerEl)||void 0===t?void 0:t.ownerDocument)||void 0===i?void 0:i.body.querySelector("body>div.excalidraw-tooltip,div.excalidraw-tooltip--visible");s&&(null===(a=null===(n=this.containerEl)||void 0===n?void 0:n.ownerDocument)||void 0===a||a.body.removeChild(s)),this.removeParentMoveObserver(),this.removeSlidingPanesListner(),this.autosaveTimer&&(clearInterval(this.autosaveTimer),this.autosaveTimer=null),this.fullscreenModalObserver&&(this.fullscreenModalObserver.disconnect(),this.fullscreenModalObserver=null)}async reload(A=!1,e){if(this.semaphores.preventReload)return void(this.semaphores.preventReload=!1);if(this.diskIcon.querySelector("svg").removeClass("excalidraw-dirty"),this.compatibilityMode)return void this.clearDirty();const t=this.excalidrawAPI;if(!this.excalidrawRef||!this.file||!t)return;const i=e&&e===this.file;i&&(this.data=await this.app.vault.read(e),this.preventAutozoom()),A?await this.excalidrawData.loadData(this.data,this.file,this.textMode):await this.excalidrawData.setTextMode(this.textMode),this.excalidrawData.scene.appState.theme=t.getAppState().theme,await this.loadDrawing(i),this.clearDirty()}zoomToElementId(A){const e=this.excalidrawAPI;if(!e)return;const t=e.getSceneElements().filter((e=>e.id===A));0!==t.length&&(e.getAppState().viewModeEnabled||e.selectElements(t),e.zoomToFit(t,this.plugin.settings.zoomToFitMaxLevel,.05))}setEphemeralState(A){if(!A)return;const e=this;let t=null;if(A.match&&A.match.content&&A.match.matches&&1===A.match.matches.length&&2===A.match.matches[0].length&&(t=[A.match.content.substring(A.match.matches[0][0],A.match.matches[0][1])]),A.subpath&&A.subpath.length>2)if("^"===A.subpath[1]){const t=A.subpath.substring(2);setTimeout((()=>e.zoomToElementId(t)),300)}else t=[`# ${A.subpath.substring(1)}`];A.line&&A.line>0&&(t=[this.data.split("\n")[A.line-1]]),t&&setTimeout((()=>{const A=e.excalidrawAPI;if(!A)return;const i=A.getSceneElements().filter((A=>"text"===A.type));e.selectElementsMatchingQuery(i,t,!A.getAppState().viewModeEnabled,!0)}),300),super.setEphemeralState(A)}clear(){const A=this.excalidrawAPI;this.excalidrawRef&&A&&(this.activeLoader&&(this.activeLoader.terminate=!0,this.activeLoader=null),this.nextLoader=null,A.resetScene(),A.history.clear(),this.previousSceneVersion=0)}async setViewData(A,e=!1){checkExcalidrawVersion(this.app),this.isLoaded=!1,e&&this.clear(),this.lastSaveTimestamp=this.file.stat.mtime,A=this.data=A.replaceAll("\r\n","\n").replaceAll("\r","\n"),this.app.workspace.onLayoutReady((async()=>{if(this.compatibilityMode="excalidraw"===this.file.extension,await this.plugin.loadSettings(),this.compatibilityMode)this.textIsRaw_Element.hide(),this.textIsParsed_Element.hide(),await this.excalidrawData.loadLegacyData(A,this.file),this.plugin.settings.compatibilityMode||new obsidian.Notice(t("COMPATIBILITY_MODE"),4e3),this.excalidrawData.disableCompression=!0;else{this.excalidrawData.disableCompression=!1;const e=getTextMode(A);this.changeTextMode(e,!1);try{if(!await this.excalidrawData.loadData(A,this.file,this.textMode))return}catch(A){return errorlog({where:"ExcalidrawView.setViewData",error:A}),new obsidian.Notice(`Error loading drawing:\n${A.message}${"Cannot read property 'index' of undefined"===A.message?"\n'# Drawing' section is likely missing":""}\n\nTry manually fixing the file or restoring an earlier version from sync history.`,1e4),void this.setMarkdownView()}}await this.loadDrawing(!0);const e=this.excalidrawData.getOnLoadScript();if(e){const A=this,t=this.file.basename+"-onlaod-script",i=()=>{A.excalidrawAPI?A.plugin.scriptEngine.executeScript(A,e,t):setTimeout(i,200)};i()}this.isLoaded=!0}))}async loadSceneFiles(){if(!this.excalidrawAPI)return;const A=new EmbeddedFilesLoader(this.plugin),e=A=>{this.nextLoader=null,this.activeLoader=A,A.loadSceneFiles(this.excalidrawData,((A,t)=>{A&&(addFiles(A,this,t),this.activeLoader=null,this.nextLoader?e(this.nextLoader):this.excalidrawData.getFiles().some((A=>{if(A&&!A.file&&A.attemptCounter<30){const A=this,e=this.file.path;return setTimeout((async()=>{A&&A.excalidrawAPI&&e===A.file.path&&A.loadSceneFiles()}),2e3),!0}return!1})))}),0)};this.activeLoader?this.nextLoader=A:e(A)}async synchronizeWithData(A){let e=0;for(;this.semaphores.saving&&e++<30;)await sleep(100);if(e>=30)return void errorlog({where:"ExcalidrawView.synchronizeWithData",message:`Aborting sync with received file (${this.file.path}) because semaphores.saving remained true for ower 3 seconds`,fn:this.synchronizeWithData});this.semaphores.saving=!0;let t=!1;try{const e=A.deletedElements.map((A=>A.id)),i=this.excalidrawAPI.getSceneElements().filter((A=>!e.contains(A.id))),n=i.map((A=>A.id)),a=e=>{switch(e.type){case"text":this.excalidrawData.textElements.set(e.id,A.textElements.get(e.id));break;case"image":A.getFile(e.fileId)?(this.excalidrawData.setFile(e.fileId,A.getFile(e.fileId)),t=!0):A.getEquation(e.fileId)&&(this.excalidrawData.setEquation(e.fileId,A.getEquation(e.fileId)),t=!0)}A.elementLinks.has(e.id)&&this.excalidrawData.elementLinks.set(e.id,A.elementLinks.get(e.id))};A.scene.elements.forEach(((e,s,r)=>{const o=i.filter((A=>A.id===e.id))[0];if(o&&(o.versionA.view.file===this.file)).length>0}setDirty(A){var e;this.semaphores.dirty=null===(e=this.file)||void 0===e?void 0:e.path,this.diskIcon.querySelector("svg").addClass("excalidraw-dirty")}clearDirty(){const A=this.excalidrawAPI;if(!A)return;this.semaphores.dirty=null;const e=A.getSceneElements();e&&(this.previousSceneVersion=this.getSceneVersion(e)),this.diskIcon.querySelector("svg").removeClass("excalidraw-dirty")}initializeToolsIconPanelAfterLoading(){var A;const e=this.excalidrawAPI;if(!e)return;const t=e.getAppState(),i=null===(A=this.toolsPanelRef)||void 0===A?void 0:A.current;i&&(i.setTheme(t.theme),i.setExcalidrawViewMode(t.viewModeEnabled),i.setPreviewMode(this.compatibilityMode?null:this.textMode===TextMode.parsed),i.updateScriptIconMap(this.plugin.scriptEngine.scriptIconMap))}canAcceptExtension(A){return"excalidraw"===A}getDisplayText(){return this.file?this.file.basename:t("NOFILE")}getViewType(){return"excalidraw"}getIcon(){return ICON_NAME}setMarkdownView(){this.plugin.excalidrawFileModes[this.id||this.file.path]="markdown",this.plugin.setMarkdownView(this.leaf)}async openAsMarkdown(){!0===this.plugin.settings.compress&&(this.excalidrawData.disableCompression=!0,await this.save(!0,!0)),this.setMarkdownView()}async convertExcalidrawToMD(){await this.save(),this.plugin.openDrawing(await this.plugin.convertSingleExcalidrawToMD(this.file),"active-pane")}onPaneMenu(A,e){this.compatibilityMode?A.addItem((A=>{A.setTitle(t("CONVERT_FILE")).onClick((()=>this.convertExcalidrawToMD())).setSection("pane")})):A.addItem((A=>{A.setTitle(t("OPEN_AS_MD")).setIcon("document").onClick((()=>{this.openAsMarkdown()})).setSection("pane")})).addItem((A=>{A.setTitle(t("EXPORT_EXCALIDRAW")).setIcon(ICON_NAME).onClick((async()=>{this.exportExcalidraw()})).setSection("pane")})),A.addItem((A=>{A.setTitle(t("SAVE_AS_PNG")).setIcon("save-png").setSection("pane").onClick((async A=>{if(this.getScene&&this.file)if(A[CTRL_OR_CMD]){const A=await this.png(this.getScene());if(!A)return;const e=new FileReader;e.readAsDataURL(A);const t=this;e.onloadend=function(){download(null,e.result,`${t.file.basename}.png`)}}else this.savePNG()})).setSection("pane")})).addItem((A=>{A.setTitle(t("SAVE_AS_SVG")).setIcon("save-svg").setSection("pane").onClick((async A=>{if(this.getScene&&this.file){if(A[CTRL_OR_CMD]){let A=await this.svg(this.getScene());return A?(A=embedFontsInSVG(A,this.plugin),void download(null,svgToBase64(A.outerHTML),`${this.file.basename}.svg`)):null}this.saveSVG()}}))})).addSeparator(),super.onPaneMenu(A,e)}async getLibrary(){var A;const e=this.plugin.getStencilLibrary();return(null==e?void 0:e.library)?e.library:null!==(A=null==e?void 0:e.libraryItems)&&void 0!==A?A:[]}async instantiateExcalidraw(A){for(;!this.semaphores.scriptsReady;)await sleep(50);const e=this.plugin.getPackage(this.ownerWindow).react,i=this.plugin.getPackage(this.ownerWindow).reactDOM;this.clearDirty();const n=e.createElement((()=>{let i={x:0,y:0};const n=e.useRef(null),a=e.useRef(null),[s,r]=e.useState({width:void 0,height:void 0});let o=null,l=null,c=null,d=0,h=!1;this.toolsPanelRef=a,this.obsidianMenu=new ObsidianMenu(this.plugin,a);const g=()=>{let A,e;const t=new Promise(((t,i)=>{A=t,e=i}));return t.resolve=A,t.reject=e,t},u=e.useMemo((()=>({current:{readyPromise:g()}})),[]);e.useEffect((()=>{u.current.readyPromise.then((A=>{var e;this.excalidrawAPI=A,A.setLocalFont(this.plugin.settings.experimentalEnableFourthFont),this.loadSceneFiles(),this.updateContainerSize(null,!0),null===(e=this.excalidrawWrapperRef.current.firstElementChild)||void 0===e||e.focus(),this.addFullscreenchangeEvent(),this.initializeToolsIconPanelAfterLoading()}))}),[u]),this.excalidrawRef=u,this.excalidrawWrapperRef=n,e.useEffect((()=>{r({width:this.contentEl.clientWidth,height:this.contentEl.clientHeight});const A=()=>{try{r({width:this.contentEl.clientWidth,height:this.contentEl.clientHeight}),this.toolsPanelRef&&this.toolsPanelRef.current&&this.toolsPanelRef.current.updatePosition(),this.ownerDocument!==document&&this.refresh()}catch(A){errorlog({where:"Excalidraw React-Wrapper, onResize",error:A})}};return this.ownerWindow.addEventListener("resize",A),()=>{var e;return null===(e=this.ownerWindow)||void 0===e?void 0:e.removeEventListener("resize",A)}}),[n]),this.getSelectedTextElement=()=>{var A;const e=this.excalidrawAPI;if(!(null==u?void 0:u.current)||!e)return{id:null,text:null};if(e.getAppState().viewModeEnabled){if(o){const A=o;return o=null,A}return{id:null,text:null}}const t=e.getSceneElements().filter((A=>A.id===Object.keys(e.getAppState().selectedElementIds)[0]));if(0===t.length)return{id:null,text:null};if("text"===t[0].type)return{id:t[0].id,text:t[0].text};if("image"===t[0].type)return{id:null,text:null};const i=null===(A=t[0].boundElements)||void 0===A?void 0:A.filter((A=>"text"===A.type));if((null==i?void 0:i.length)>0){const A=e.getSceneElements().filter((A=>A.id===i[0].id));if(A.length>0)return{id:A[0].id,text:A[0].text}}if(0===t[0].groupIds.length)return{id:null,text:null};const n=t[0].groupIds[0],a=e.getSceneElements().filter((A=>{var e;return null===(e=A.groupIds)||void 0===e?void 0:e.includes(n)})).filter((A=>"text"===A.type));return 0===a.length?{id:null,text:null}:{id:t[0].id,text:t[0].text}},this.getSelectedImageElement=()=>{const A=this.excalidrawAPI;if(!A)return{id:null,fileId:null};if(A.getAppState().viewModeEnabled){if(l){const A=l;return l=null,A}return{id:null,fileId:null}}const e=A.getSceneElements().filter((e=>e.id==Object.keys(A.getAppState().selectedElementIds)[0]));if(0===e.length)return{id:null,fileId:null};if("image"==e[0].type)return{id:e[0].id,fileId:e[0].fileId};if("text"===e[0].type)return{id:null,fileId:null};if(0===e[0].groupIds.length)return{id:null,fileId:null};const t=e[0].groupIds[0],i=A.getSceneElements().filter((A=>{var e;return null===(e=A.groupIds)||void 0===e?void 0:e.includes(t)})).filter((A=>"image"==A.type));return 0===i.length?{id:null,fileId:null}:{id:i[0].id,fileId:i[0].fileId}},this.getSelectedElementWithLink=()=>{const A=this.excalidrawAPI;if(!A)return{id:null,text:null};if(A.getAppState().viewModeEnabled){if(c){const A=c;return c=null,A}return{id:null,text:null}}const e=A.getSceneElements().filter((e=>e.id==Object.keys(A.getAppState().selectedElementIds)[0]));if(0===e.length)return{id:null,text:null};if(e[0].link)return{id:e[0].id,text:e[0].link};if(0===e[0].groupIds.length)return{id:null,text:null};const t=e[0].groupIds[0],i=A.getSceneElements().filter((A=>{var e;return null===(e=A.groupIds)||void 0===e?void 0:e.includes(t)})).filter((A=>A.link));return 0===i.length?{id:null,text:null}:{id:i[0].id,text:i[0].link}},this.addText=async(A,e,t=!0)=>{var n,a,s,r,o;const l=this.excalidrawAPI;if(!(null==u?void 0:u.current)||!l)return;const c=l.getAppState(),d=this.plugin.ea;d.reset(),d.style.strokeColor=null!==(n=c.currentItemStrokeColor)&&void 0!==n?n:"black",d.style.opacity=null!==(a=c.currentItemOpacity)&&void 0!==a?a:1,d.style.fontFamily=null!==(s=null!=e?e:c.currentItemFontFamily)&&void 0!==s?s:1,d.style.fontSize=null!==(r=c.currentItemFontSize)&&void 0!==r?r:20,d.style.textAlign=null!==(o=c.currentItemTextAlign)&&void 0!==o?o:"left";const h=d.addText(i.x,i.y,A);return await this.addElements(d.getElements(),!1,t),h},this.addElements=async(A,e=!1,t=!1,n,a=!1)=>{const s=this.excalidrawAPI;if(!(null==u?void 0:u.current)||!s)return!1;const r=A.filter((A=>"text"==A.type));for(let A=0;AA.id)),l=s.getSceneElements(),c=[];for(let e=0;eA.id===t))[0],c.push(t))}const d=a?l.concat(A.filter((A=>!c.includes(A.id)))):A.filter((A=>!c.includes(A.id))).concat(l);if(this.updateScene({elements:d,commitToHistory:!0}),n){const A=[];Object.keys(n).forEach((e=>{if(A.push({mimeType:n[e].mimeType,id:n[e].id,dataURL:n[e].dataURL,created:n[e].created}),n[e].file){const A=new EmbeddedFile(this.plugin,this.file.path,n[e].file),t=s.getAppState();A.setImage(n[e].dataURL,n[e].mimeType,n[e].size,"dark"===t.theme,n[e].hasSVGwithBitmap),this.excalidrawData.setFile(n[e].id,A)}n[e].latex&&this.excalidrawData.setEquation(n[e].id,{latex:n[e].latex,isLoaded:!0})})),s.addFiles(A)}return t?await this.save(!1):this.setDirty(5),!0},this.getScene=()=>{const A=this.excalidrawAPI;if(!(null==u?void 0:u.current)||!A)return null;const e=A.getSceneElements(),t=A.getAppState(),i=A.getFiles();if(i){const A=e.filter((A=>"image"===A.type)).map((A=>A.fileId));Object.keys(i).filter((e=>!A.contains(e))).forEach((A=>delete i[A]))}return{type:"excalidraw",version:2,source:"https://excalidraw.com",elements:e,appState:{theme:t.theme,viewBackgroundColor:t.viewBackgroundColor,currentItemStrokeColor:t.currentItemStrokeColor,currentItemBackgroundColor:t.currentItemBackgroundColor,currentItemFillStyle:t.currentItemFillStyle,currentItemStrokeWidth:t.currentItemStrokeWidth,currentItemStrokeStyle:t.currentItemStrokeStyle,currentItemRoughness:t.currentItemRoughness,currentItemOpacity:t.currentItemOpacity,currentItemFontFamily:t.currentItemFontFamily,currentItemFontSize:t.currentItemFontSize,currentItemTextAlign:t.currentItemTextAlign,currentItemStrokeSharpness:t.currentItemStrokeSharpness,currentItemStartArrowhead:t.currentItemStartArrowhead,currentItemEndArrowhead:t.currentItemEndArrowhead,currentItemLinearStrokeSharpness:t.currentItemLinearStrokeSharpness,gridSize:t.gridSize,colorPalette:t.colorPalette},files:i}},this.refresh=()=>{const A=this.excalidrawAPI;(null==u?void 0:u.current)&&A&&A.refresh()};let w={x:0,y:0},p=null;const B=()=>{if(p){const A=new MouseEvent("click",{view:this.ownerWindow,bubbles:!0,cancelable:!0});p.dispatchEvent(A),p=null}},m=A=>{var e,t,i,n,a;const s=null===(e=this.app.dragManager.draggable)||void 0===e?void 0:e.files;return s&&s[0]==this.file&&(s.shift(),this.app.dragManager.draggable.title=`${s.length} files`),["file","files"].includes(null===(t=this.app.dragManager.draggable)||void 0===t?void 0:t.type)?"link":(null===(i=A.types)||void 0===i?void 0:i.includes("text/html"))||(null===(n=A.types)||void 0===n?void 0:n.includes("text/plain"))||(null===(a=A.types)||void 0===a?void 0:a.includes("Files"))?"copy":void 0};let f=!1;const E=()=>{if(o=getTextElementAtPointer(i,this),o&&o.id){const A=new MouseEvent("click",{ctrlKey:!0,metaKey:this.metaKeyDown,shiftKey:this.shiftKeyDown,altKey:this.altKeyDown});return this.handleLinkClick(this,A),void(o=null)}if(l=getImageElementAtPointer(i,this),l&&l.id){const A=new MouseEvent("click",{ctrlKey:!0,metaKey:this.metaKeyDown,shiftKey:this.shiftKeyDown,altKey:this.altKeyDown});return this.handleLinkClick(this,A),void(l=null)}if(c=getElementWithLinkAtPointer(i,this),c&&c.id){const A=new MouseEvent("click",{ctrlKey:!0,metaKey:this.metaKeyDown,shiftKey:this.shiftKeyDown,altKey:this.altKeyDown});return this.handleLinkClick(this,A),void(c=null)}};let C=null;const F=(A,e)=>{if(!A){if(!i)return;A="";const t=getTextElementAtPointer(i,this);if(t&&t.text){e=this.excalidrawAPI.getSceneElements().filter((A=>A.id===t.id))[0];const i=this.textMode===TextMode.parsed?this.excalidrawData.getRawText(t.id):t.text;if(!i)return;if(i.match(REG_LINKINDEX_HYPERLINK))return;const n=REGEX_LINK.getRes(i).next();if(!n.value)return;if((A=REGEX_LINK.getLink(n)).match(REG_LINKINDEX_HYPERLINK))return}else{const t=getImageElementAtPointer(i,this);if(e=this.excalidrawAPI.getSceneElements().filter((A=>A.id===t.id))[0],!t||!t.fileId)return;if(!this.excalidrawData.hasFile(t.fileId))return;const n=this.excalidrawData.getFile(t.fileId),a=n.linkParts.ref?`#${n.linkParts.isBlockRef?"^":""}${n.linkParts.ref}`:"";A=this.excalidrawData.getFile(t.fileId).file.path+a}}if(this.getHookServer().onLinkHoverHook)try{if(!this.getHookServer().onLinkHoverHook(e,A,this,this.getHookServer()))return}catch(A){errorlog({where:"ExcalidrawView.showHoverPreview",fn:this.getHookServer().onLinkHoverHook,error:A})}if(this.semaphores.hoverSleep)return;const t=this.app.metadataCache.getFirstLinkpathDest(A.split("#")[0],this.file.path);if(!t)return;if(this.ownerDocument.querySelector(`div.popover-title[data-path="${t.path}"]`))return;this.semaphores.hoverSleep=!0;const n=this;if(setTimeout((()=>n.semaphores.hoverSleep=!1),500),this.plugin.hover.linkText=A,this.plugin.hover.sourcePath=this.file.path,p=this.contentEl,this.app.workspace.trigger("hover-link",{event:C,source:"excalidraw",hoverParent:p,targetEl:p,linktext:this.plugin.hover.linkText,sourcePath:this.plugin.hover.sourcePath}),w=i,this.isFullscreen()){const A=this;setTimeout((()=>{var e,i,n,a;const s=null!==(a=null===(n=null===(i=null===(e=this.ownerDocument.querySelector(`div.popover-title[data-path="${t.path}"]`))||void 0===e?void 0:e.parentElement)||void 0===i?void 0:i.parentElement)||void 0===n?void 0:n.parentElement)&&void 0!==a?a:this.ownerDocument.body.querySelector("div.popover");s&&A.contentEl.append(s)}),400)}},{Excalidraw:v}=this.plugin.getPackage(this.ownerWindow).excalidrawLib,y=e.createElement("div",{className:"excalidraw-wrapper",ref:n,key:"abc",tabIndex:0,onKeyDown:A=>{A.target!==y.ref.current&&(this.isFullscreen()&&A.keyCode===KEYCODE.ESC&&this.exitFullscreen(),!A[CTRL_OR_CMD]||A.shiftKey||A.altKey||F())},onClick:A=>{(A[CTRL_OR_CMD]||A.metaKey)&&(this.plugin.settings.allowCtrlClick||A.metaKey)&&(this.getSelectedTextElement().id||this.getSelectedImageElement().id||this.getSelectedElementWithLink().id)&&this.handleLinkClick(this,A)},onMouseMove:A=>{C=A.nativeEvent},onMouseOver:()=>{B()},onDragOver:A=>{const e=m(A.dataTransfer);if(e)return A.dataTransfer.dropEffect=e,A.preventDefault(),!1},onDragLeave:()=>{}},e.createElement(v,{ref:u,width:s.width,height:s.height,UIOptions:{canvasActions:{loadScene:!1,saveScene:!1,saveAsScene:!1,export:{saveFileToDisk:!1},saveAsImage:!1,saveToActiveFile:!1}},initialData:A,detectScroll:!0,onPointerUpdate:A=>{if(i=A.pointer,p&&(Math.abs(w.x-A.pointer.x)>50||Math.abs(w.y-A.pointer.y)>50)&&B(),f){if(!h&&"down"===A.button){if(h=!0,this.ctrlKeyDown||this.metaKeyDown)return void E();const A=(new Date).getTime();return A-d<600&&E(),void(d=A)}"up"===A.button&&(h=!1),(this.ctrlKeyDown||this.excalidrawAPI.getAppState().isViewModeEnabled&&this.plugin.settings.hoverPreviewWithoutCTRL)&&F()}},libraryReturnUrl:"app://obsidian.md",autoFocus:!0,onChange:(A,e)=>{if(f=e.viewModeEnabled,this.semaphores.justLoaded)return this.semaphores.justLoaded=!1,this.semaphores.preventAutozoom||this.zoomToFit(!1),this.previousSceneVersion=this.getSceneVersion(A),void(this.previousBackgroundColor=e.viewBackgroundColor);if(!this.semaphores.dirty&&null===e.editingElement&&null===e.editingLinearElement){const t=this.getSceneVersion(A);((t>0||0===t&&A.length>0)&&t!==this.previousSceneVersion||e.viewBackgroundColor!==this.previousBackgroundColor)&&(this.previousSceneVersion=t,this.previousBackgroundColor=e.viewBackgroundColor,this.setDirty(6))}},onLibraryChange:A=>{(async()=>{const e={type:"excalidrawlib",version:2,source:"https://excalidraw.com",libraryItems:A};this.plugin.setStencilLibrary(e),await this.plugin.saveSettings()})()},renderTopRightUI:this.obsidianMenu.renderButton,onPaste:A=>{if(A.elements){const A=this;setTimeout((()=>A.save(!1)),300)}return!0},onThemeChange:async A=>{var e;this.excalidrawData.scene.appState.theme=A,this.loadSceneFiles(),null===(e=null==a?void 0:a.current)||void 0===e||e.setTheme(A)},ownerDocument:this.ownerDocument,ownerWindow:this.ownerWindow,onDrop:A=>{const e=this.excalidrawAPI;if(!e)return!1;const n=e.getAppState();i=viewportCoordsToSceneCoords({clientX:A.clientX,clientY:A.clientY},n);const a=this.app.dragManager.draggable,s=(e,t,n)=>{if(!this.getHookServer().onDropHook)return!1;try{return this.getHookServer().onDropHook({ea:this.getHookServer(),event:A,draggable:a,type:e,payload:{files:t,text:n},excalidrawFile:this.file,view:this,pointerPosition:i})}catch(A){return new obsidian.Notice("on drop hook error. See console log for details"),errorlog({where:"ExcalidrawView.onDrop",error:A}),!1}};switch(A[CTRL_OR_CMD]=A.shiftKey||A[CTRL_OR_CMD],null==a?void 0:a.type){case"file":if(!s("file",[a.file],null)){if(a.file.path.match(REG_LINKINDEX_INVALIDCHARS))return new obsidian.Notice(t("FILENAME_INVALID_CHARS"),4e3),!1;if(A[CTRL_OR_CMD]&&(IMAGE_TYPES.contains(a.file.extension)||"md"===a.file.extension)){const A=this.plugin.ea;return A.reset(),A.setView(this),(async()=>{A.canvas.theme=e.getAppState().theme,await A.addImage(i.x,i.y,a.file),A.addElementsToView(!1,!1,!0)})(),!1}this.addText(`[[${this.app.metadataCache.fileToLinktext(a.file,this.file.path,!0)}]]`)}return!1;case"files":return s("file",a.files,null)||(async()=>{if(A[CTRL_OR_CMD]){const A=this.plugin.ea;A.reset(),A.setView(this),A.canvas.theme=e.getAppState().theme;let t=0;for(const e of a.files)(IMAGE_TYPES.contains(e.extension)||"md"===e.extension)&&(await A.addImage(i.x+50*t,i.y+50*t,e),t++,await A.addElementsToView(!1,!1,!0))}else{for(const A of a.files)await this.addText(`[[${this.app.metadataCache.fileToLinktext(A,this.file.path,!0)}]]`,void 0,!1),i.y+=2*n.currentItemFontSize;this.save(!1)}})(),!1}if(A.dataTransfer.types.includes("text/plain")){const e=A.dataTransfer.getData("text");if(!e)return!0;if(!s("text",null,e)){if(this.plugin.settings.iframelyAllowed&&e.match(/^https?:\/\/\S*$/))return(async()=>{var A;const t=await this.addText(e),i=`http://iframely.server.crestify.com/iframely?url=${e}`,n=JSON.parse(await obsidian.request({url:i}));if(!n||n.error||!(null===(A=n.meta)||void 0===A?void 0:A.title))return!1;const a=this.plugin.ea;a.reset(),a.setView(this);const s=a.getViewElements().filter((A=>A.id===t));1===s.length&&(s[0].text=s[0].originalText=s[0].rawText=`[${n.meta.title}](${e})`,a.copyViewElementsToEAforEditing(s),a.addElementsToView(!1,!1,!1))})(),!1;if(e.startsWith("obsidian://open?vault=")){const t=A.dataTransfer.getData("text/html");if(t){const A=t.match(/href="app:\/\/obsidian\.md\/(.*?)"/);if(2===A.length){const e=decodeURIComponent(A[1]).split("#"),t=app.vault.getAbstractFileByPath(e[0]);if(t&&t instanceof obsidian.TFile){const A=app.metadataCache.fileToLinktext(t,this.file.path);return void this.addText(`[[${A+(e.length>1?"#"+e[1]+"|"+A:"")}]]`)}return this.addText(`[[${decodeURIComponent(A[1])}]]`),!1}}const i=e.split("file=");if(2===i.length)return this.addText(`[[${decodeURIComponent(i[1])}]]`),!1}this.addText(e.replace(/(!\[\[.*#[^\]]*\]\])/g,"$1{40}"))}return!1}return!s("unknown",null,null)},onBeforeTextEdit:A=>{clearTimeout(this.isEditingTextResetTimer),this.isEditingTextResetTimer=null,this.semaphores.isEditingText=!0;return this.excalidrawData.getRawText(A.id)||A.rawText},onBeforeTextSubmit:(A,e,t,i)=>{const n=this.excalidrawAPI;if(!n)return[null,null,null];if(this.semaphores.isEditingText=!0,this.isEditingTextResetTimer=setTimeout((()=>{this.semaphores.isEditingText=!1,this.isEditingTextResetTimer=null}),1500),i)return this.excalidrawData.deleteTextElement(A.id),this.setDirty(7),[null,null,null];const a=A.containerId;if(e!==A.text||t!==A.originalText||!this.excalidrawData.getRawText(A.id)){this.setDirty(8);const[i,s,r]=this.excalidrawData.setTextElement(A.id,e,t,(async()=>{await this.save(!1),this.textMode===TextMode.parsed&&n.history.clear()}));return i?(a&&this.updateContainerSize(a,!0),this.textMode===TextMode.raw?[e,t,r]:e===i?r?[i,s,r]:[null,null,null]:(n.history.clear(),[i,s,r])):[null,null,null]}return a&&this.updateContainerSize(a,!0),this.textMode===TextMode.parsed?this.excalidrawData.getParsedText(A.id):[null,null,null]},onLinkOpen:async(A,e)=>{var i;if(e.preventDefault(),!A)return;const n=A.link;if(!n||""===n)return;const a=this.ownerDocument.body.querySelector("body>div.excalidraw-tooltip,div.excalidraw-tooltip--visible");a&&this.ownerDocument.body.removeChild(a);const s=null===(i=null==e?void 0:e.detail)||void 0===i?void 0:i.nativeEvent;if(this.getHookServer().onLinkClickHook)try{if(!this.getHookServer().onLinkClickHook(A,A.link,s,this,this.getHookServer()))return}catch(e){errorlog({where:"ExcalidrawView.onLinkOpen",fn:this.getHookServer().onLinkClickHook,error:e})}n.startsWith("md://")||n.startsWith("[[")?(async()=>{const A=n.match(/(md:\/\/)?\[\[(?.*?)\]\]/);if(!A)return;let e=A.groups.link,i=null;if(e.search("#")>-1){const A=getLinkParts(e,this.file);i=`#${A.isBlockRef?"^":""}${A.ref}`,e=A.path}if(e.match(REG_LINKINDEX_INVALIDCHARS))return void new obsidian.Notice(t("FILENAME_INVALID_CHARS"),4e3);const a=this.app.metadataCache.getFirstLinkpathDest(e,this.file.path),r=s.shiftKey||s[CTRL_OR_CMD]||this.linksAlwaysOpenInANewPane||s.metaKey;if(r&&this.isFullscreen()&&this.exitFullscreen(),a)if(a===this.file){if(i)return void this.setEphemeralState({subpath:i});this.zoomToFit(!1)}else try{const A=r?s.metaKey&&!app.isMobile?app.workspace.openPopoutLeaf():getNewOrAdjacentLeaf(this.plugin,this.leaf):this.leaf;await A.openFile(a,i?{active:!1,eState:{subpath:i}}:{active:!1})}catch(A){new obsidian.Notice(A,4e3)}else new NewFileActions(this.plugin,e,r,!app.isMobile&&s.metaKey,this).open()})():window.open(n)},onLinkHover:(A,e)=>{if(A&&(this.plugin.settings.hoverPreviewWithoutCTRL||e[CTRL_OR_CMD])){C=e,C.ctrlKey=!0;const t=A.link;if(!t||""===t)return;if(t.startsWith("md://")||t.startsWith("[[")){const e=t.match(/(md:\/\/)?\[\[(?.*?)\]\]/);if(!e)return;let i=e.groups.link;F(i,A)}}},onViewModeChange:A=>{var e,t;if(null===(t=null===(e=this.toolsPanelRef)||void 0===e?void 0:e.current)||void 0===t||t.setExcalidrawViewMode(A),this.getHookServer().onViewModeChangeHook)try{this.getHookServer().onViewModeChangeHook(A,this,this.getHookServer())}catch(A){errorlog({where:"ExcalidrawView.onViewModeChange",fn:this.getHookServer().onViewModeChangeHook,error:A})}}}),e.createElement(ToolsPanel,{ref:a,visible:!1,view:this,centerPointer:()=>{const A=this.excalidrawAPI;if(!u||!u.current||!A)return;const e=A.getAppState(),{width:t,height:n}=e;i=viewportCoordsToSceneCoords({clientX:t/2,clientY:n/2},e)}})),Q=e.useRef(new ResizeObserver((A=>{const{width:e,height:t}=A[0].contentRect,i=a.current.onRightEdge?a.current.previousWidth-e:0,n=a.current.onBottomEdge?a.current.previousHeight-t:0;a.current.updatePosition(n,i)})));return e.useEffect((()=>(a.current&&Q.current.observe(a.current.containerRef.current),()=>{Q.current.unobserve(a.current.containerRef.current)})),[a,Q]),e.createElement(e.Fragment,null,y)}));i.render(n,this.contentEl,(()=>{}))}updateContainerSize(A,e=!1){const t=this.excalidrawAPI;if(!t)return;const i=()=>{const e=A?t.getSceneElements().filter((e=>e.id===A)):t.getSceneElements().filter((A=>{var e;return null===(e=A.boundElements)||void 0===e?void 0:e.map((A=>A.type)).includes("text")}));e.length>0&&(this.initialContainerSizeUpdate&&(this.semaphores.justLoaded=!0),t.updateContainerSize(e)),this.initialContainerSizeUpdate=!1};e?setTimeout((()=>i()),50):i()}zoomToFit(A=!0){const e=this.excalidrawAPI;if(!e||!this.excalidrawRef||this.semaphores.isEditingText)return;const t=this.plugin.settings.zoomToFitMaxLevel,i=e.getSceneElements();A?setTimeout((()=>e.zoomToFit(i,t,this.isFullscreen()?0:.05)),100):e.zoomToFit(i,t,this.isFullscreen()?0:.05)}async toggleTrayMode(){const A=this.excalidrawAPI;if(!A)return!1;const e=A.getAppState();A.updateScene({appState:{trayModeEnabled:!e.trayModeEnabled}}),await this.plugin.loadSettings(),this.plugin.settings.defaultTrayMode=!e.trayModeEnabled,this.plugin.saveSettings()}selectElementsMatchingQuery(A,e,t=!0,i=!1){if(!A||0===A.length||!e||0===e.length)return;const n=A.filter((A=>e.some((e=>{if(i){const t=A.rawText.toLowerCase().split("\n")[0].trim().match(/^#*(# .*)/);return!(!t||2!==t.length)&&t[1]===e.toLowerCase()}return A.rawText.toLowerCase().replaceAll("\n"," ").trim().match(e.toLowerCase())}))));if(0===n.length)return void new obsidian.Notice("I could not find a matching text element");const a=this.excalidrawAPI;a&&(t&&a.selectElements(n),a.zoomToFit(n,this.plugin.settings.zoomToFitMaxLevel,.05))}getViewSelectedElements(){var A;const e=this.excalidrawAPI;if(!e)return;const t=null===(A=e.getAppState())||void 0===A?void 0:A.selectedElementIds;if(!t)return[];const i=Object.keys(t);if(!i)return[];const n=e.getSceneElements().filter((A=>i.includes(A.id))),a=n.filter((A=>A.boundElements&&A.boundElements.filter((A=>"text"===A.type)).length>0)).map((A=>A.boundElements.filter((A=>"text"===A.type)).map((A=>A.id))[0])),s=n.map((A=>A.id)).concat(a);return e.getSceneElements().filter((A=>s.contains(A.id)))}async copyLinkToSelectedElementToClipboard(){const A=this.getViewSelectedElements();if(1!==A.length)return void new obsidian.Notice(t("INSERT_LINK_TO_ELEMENT_ERROR"));const e=await ScriptEngine.inputPrompt(this.app,"Set link alias","Leave empty if you do not want to set an alias","");navigator.clipboard.writeText(`[[${this.file.path}#^${A[0].id}${e?`|${e}`:""}]]`),new obsidian.Notice(t("INSERT_LINK_TO_ELEMENT_READY"))}updateScene(A,e=!1){const t=this.excalidrawAPI;if(!t)return;const i=A.elements&&e;i&&(A.elements=t.restore(A).elements);try{t.updateScene(A)}catch(e){if(errorlog({where:"ExcalidrawView.updateScene 1st attempt",fn:this.updateScene,error:e,scene:A,willDoSecondAttempt:!i}),i)warningUnknowSeriousError();else try{A.elements=t.restore(A).elements,t.updateScene(A)}catch(e){errorlog({where:"ExcalidrawView.updateScene 2nd attempt",fn:this.updateScene,error:e,scene:A}),warningUnknowSeriousError()}}}}function getTextMode(A){return A.search("excalidraw-plugin: parsed\n")>-1||A.search("excalidraw-plugin: locked\n")>-1?TextMode.parsed:TextMode.raw}const DEFAULT_SETTINGS={folder:"Excalidraw",embedUseExcalidrawFolder:!1,templateFilePath:"Excalidraw/Template.excalidraw",scriptFolderPath:"Excalidraw/Scripts",compress:!1,autosave:!0,autosaveInterval:15e3,drawingFilenamePrefix:"Drawing ",drawingEmbedPrefixWithFilename:!0,drawingFilnameEmbedPostfix:" ",drawingFilenameDateTime:"YYYY-MM-DD HH.mm.ss",useExcalidrawExtension:!0,displaySVGInPreview:!0,displayExportedImageIfAvailable:!1,previewMatchObsidianTheme:!1,width:"400",isLeftHanded:!1,matchTheme:!1,matchThemeAlways:!1,matchThemeTrigger:!1,defaultMode:"normal",defaultPenMode:"never",zoomToFitOnResize:!0,zoomToFitMaxLevel:2,linkPrefix:"📍",urlPrefix:"🌐",hoverPreviewWithoutCTRL:!1,linkOpacity:1,openInAdjacentPane:!1,openInMainWorkspace:!0,showLinkBrackets:!0,allowCtrlClick:!0,forceWrap:!1,pageTransclusionCharLimit:200,wordWrappingDefault:0,iframelyAllowed:!0,pngExportScale:1,exportWithTheme:!0,exportWithBackground:!0,exportPaddingSVG:10,keepInSync:!1,autoexportSVG:!1,autoexportPNG:!1,autoexportExcalidraw:!1,embedType:"excalidraw",embedWikiLink:!0,syncExcalidraw:!1,experimentalFileType:!1,experimentalFileTag:"✏️",experimentalLivePreview:!0,experimentalEnableFourthFont:!1,experimantalFourthFont:"Virgil",fieldSuggester:!0,compatibilityMode:!1,drawingOpenCount:0,library:"deprecated",library2:{type:"excalidrawlib",version:2,source:"https://excalidraw.com",libraryItems:[]},imageElementNotice:!0,mdSVGwidth:500,mdSVGmaxHeight:800,mdFont:"Virgil",mdFontColor:"Black",mdBorderColor:"Black",mdCSS:"",scriptEngineSettings:{},defaultTrayMode:!1,previousRelease:"1.6.13",showReleaseNotes:!0,mathjaxSourceURL:"https://cdn.jsdelivr.net/npm/mathjax@3.2.1/es5/tex-svg.js"},fragWithHTML=A=>createFragment((e=>e.createDiv().innerHTML=A));class ExcalidrawSettingTab extends obsidian.PluginSettingTab{constructor(A,e){super(A,e),this.requestEmbedUpdate=!1,this.requestReloadDrawings=!1,this.reloadMathJax=!1,this.plugin=e}applySettingsUpdate(A=!1){A&&(this.requestReloadDrawings=!0)}async hide(){if(this.plugin.settings.scriptFolderPath=obsidian.normalizePath(this.plugin.settings.scriptFolderPath),"/"!==this.plugin.settings.scriptFolderPath&&""!==this.plugin.settings.scriptFolderPath||(this.plugin.settings.scriptFolderPath="Excalidraw/Scripts"),this.plugin.saveSettings(),this.requestReloadDrawings){const A=this.plugin.app.workspace.getLeavesOfType("excalidraw");for(const e of A)e.view instanceof ExcalidrawView&&(await e.view.save(!1),await e.view.reload(!0));this.requestEmbedUpdate=!0}this.requestEmbedUpdate&&this.plugin.triggerEmbedUpdates(),this.plugin.scriptEngine.updateScriptPath(),this.reloadMathJax&&this.plugin.loadMathJax()}async display(){var A;await this.plugin.loadSettings(),this.requestEmbedUpdate=!1,this.requestReloadDrawings=!1;const{containerEl:e}=this;this.containerEl.empty();const i=e.createDiv("coffee");i.addClass("ex-coffee-div"),i.createEl("a",{href:"https://ko-fi.com/zsolt"}).createEl("img",{attr:{src:"https://cdn.ko-fi.com/cdn/kofi3.png?v=3"}}).height=45,new obsidian.Setting(e).setName(t("RELEASE_NOTES_NAME")).setDesc(fragWithHTML(t("RELEASE_NOTES_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.showReleaseNotes).onChange((async A=>{this.plugin.settings.showReleaseNotes=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("FOLDER_NAME")).setDesc(fragWithHTML(t("FOLDER_DESC"))).addText((A=>A.setPlaceholder("Excalidraw").setValue(this.plugin.settings.folder).onChange((async A=>{this.plugin.settings.folder=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("FOLDER_EMBED_NAME")).setDesc(fragWithHTML(t("FOLDER_EMBED_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.embedUseExcalidrawFolder).onChange((async A=>{this.plugin.settings.embedUseExcalidrawFolder=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("TEMPLATE_NAME")).setDesc(fragWithHTML(t("TEMPLATE_DESC"))).addText((A=>A.setPlaceholder("Excalidraw/Template").setValue(this.plugin.settings.templateFilePath).onChange((async A=>{this.plugin.settings.templateFilePath=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("SCRIPT_FOLDER_NAME")).setDesc(fragWithHTML(t("SCRIPT_FOLDER_DESC"))).addText((A=>A.setPlaceholder("Excalidraw/Scripts").setValue(this.plugin.settings.scriptFolderPath).onChange((async A=>{this.plugin.settings.scriptFolderPath=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("COMPRESS_NAME")).setDesc(fragWithHTML(t("COMPRESS_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.compress).onChange((async A=>{this.plugin.settings.compress=A,this.applySettingsUpdate()})))),this.containerEl.createEl("h1",{text:t("FILENAME_HEAD")}),e.createDiv("",(A=>{A.innerHTML=t("FILENAME_DESC")}));const n=()=>`${t("FILENAME_SAMPLE")}${getDrawingFilename(this.plugin.settings)}
${t("FILENAME_EMBED_SAMPLE")}${getEmbedFilename("{NOTE_NAME}",this.plugin.settings)}`,a=e.createEl("p",{text:""});let s,r,o,l,c;a.innerHTML=n(),new obsidian.Setting(e).setName(t("FILENAME_PREFIX_NAME")).setDesc(fragWithHTML(t("FILENAME_PREFIX_DESC"))).addText((A=>A.setPlaceholder("Drawing ").setValue(this.plugin.settings.drawingFilenamePrefix).onChange((async e=>{this.plugin.settings.drawingFilenamePrefix=e.replaceAll(/[<>:"/\\|?*]/g,"_"),A.setValue(this.plugin.settings.drawingFilenamePrefix),a.innerHTML=n(),this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("FILENAME_PREFIX_EMBED_NAME")).setDesc(fragWithHTML(t("FILENAME_PREFIX_EMBED_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.drawingEmbedPrefixWithFilename).onChange((async A=>{this.plugin.settings.drawingEmbedPrefixWithFilename=A,a.innerHTML=n(),this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("FILENAME_POSTFIX_NAME")).setDesc(fragWithHTML(t("FILENAME_POSTFIX_DESC"))).addText((A=>A.setPlaceholder("").setValue(this.plugin.settings.drawingFilnameEmbedPostfix).onChange((async e=>{this.plugin.settings.drawingFilnameEmbedPostfix=e.replaceAll(/[<>:"/\\|?*]/g,"_"),A.setValue(this.plugin.settings.drawingFilnameEmbedPostfix),a.innerHTML=n(),this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("FILENAME_DATE_NAME")).setDesc(fragWithHTML(t("FILENAME_DATE_DESC"))).addText((A=>A.setPlaceholder("YYYY-MM-DD HH.mm.ss").setValue(this.plugin.settings.drawingFilenameDateTime).onChange((async e=>{this.plugin.settings.drawingFilenameDateTime=e.replaceAll(/[<>:"/\\|?*]/g,"_"),A.setValue(this.plugin.settings.drawingFilenameDateTime),a.innerHTML=n(),this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("FILENAME_EXCALIDRAW_EXTENSION_NAME")).setDesc(fragWithHTML(t("FILENAME_EXCALIDRAW_EXTENSION_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.useExcalidrawExtension).onChange((async A=>{this.plugin.settings.useExcalidrawExtension=A,a.innerHTML=n(),this.applySettingsUpdate()})))),this.containerEl.createEl("h1",{text:t("DISPLAY_HEAD")}),new obsidian.Setting(e).setName(t("LEFTHANDED_MODE_NAME")).setDesc(fragWithHTML(t("LEFTHANDED_MODE_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.isLeftHanded).onChange((async A=>{this.plugin.settings.isLeftHanded=A,setLeftHandedMode(A),this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("MATCH_THEME_NAME")).setDesc(fragWithHTML(t("MATCH_THEME_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.matchTheme).onChange((async A=>{this.plugin.settings.matchTheme=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("MATCH_THEME_ALWAYS_NAME")).setDesc(fragWithHTML(t("MATCH_THEME_ALWAYS_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.matchThemeAlways).onChange((async A=>{this.plugin.settings.matchThemeAlways=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("MATCH_THEME_TRIGGER_NAME")).setDesc(fragWithHTML(t("MATCH_THEME_TRIGGER_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.matchThemeTrigger).onChange((async A=>{this.plugin.settings.matchThemeTrigger=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("DEFAULT_OPEN_MODE_NAME")).setDesc(fragWithHTML(t("DEFAULT_OPEN_MODE_DESC"))).addDropdown((A=>A.addOption("normal","Normal Mode").addOption("zen","Zen Mode").addOption("view","View Mode").setValue(this.plugin.settings.defaultMode).onChange((async A=>{this.plugin.settings.defaultMode=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("DEFAULT_PEN_MODE_NAME")).setDesc(fragWithHTML(t("DEFAULT_PEN_MODE_DESC"))).addDropdown((A=>A.addOption("never","Never").addOption("mobile","On Obsidian Mobile").addOption("always","Always").setValue(this.plugin.settings.defaultPenMode).onChange((async A=>{this.plugin.settings.defaultPenMode=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("ZOOM_TO_FIT_NAME")).setDesc(fragWithHTML(t("ZOOM_TO_FIT_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.zoomToFitOnResize).onChange((async A=>{this.plugin.settings.zoomToFitOnResize=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("ZOOM_TO_FIT_MAX_LEVEL_NAME")).setDesc(fragWithHTML(t("ZOOM_TO_FIT_MAX_LEVEL_DESC"))).addSlider((A=>A.setLimits(.5,10,.5).setValue(this.plugin.settings.zoomToFitMaxLevel).onChange((async A=>{s.innerText=` ${A.toString()}`,this.plugin.settings.zoomToFitMaxLevel=A,this.applySettingsUpdate()})))).settingEl.createDiv("",(A=>{s=A,A.style.minWidth="2.3em",A.style.textAlign="right",A.innerText=` ${this.plugin.settings.zoomToFitMaxLevel.toString()}`})),this.containerEl.createEl("h1",{text:t("LINKS_HEAD")}),this.containerEl.createEl("span",void 0,(A=>A.innerHTML=t("LINKS_DESC"))),new obsidian.Setting(e).setName(t("ADJACENT_PANE_NAME")).setDesc(fragWithHTML(t("ADJACENT_PANE_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.openInAdjacentPane).onChange((async A=>{this.plugin.settings.openInAdjacentPane=A,this.applySettingsUpdate(!0)})))),new obsidian.Setting(e).setName(t("MAINWORKSPACE_PANE_NAME")).setDesc(fragWithHTML(t("MAINWORKSPACE_PANE_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.openInMainWorkspace).onChange((async A=>{this.plugin.settings.openInMainWorkspace=A,this.applySettingsUpdate(!0)})))),new obsidian.Setting(e).setName(t("LINK_BRACKETS_NAME")).setDesc(fragWithHTML(t("LINK_BRACKETS_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.showLinkBrackets).onChange((async A=>{this.plugin.settings.showLinkBrackets=A,this.applySettingsUpdate(!0)})))),new obsidian.Setting(e).setName(t("LINK_PREFIX_NAME")).setDesc(fragWithHTML(t("LINK_PREFIX_DESC"))).addText((A=>A.setPlaceholder(t("INSERT_EMOJI")).setValue(this.plugin.settings.linkPrefix).onChange((A=>{this.plugin.settings.linkPrefix=A,this.applySettingsUpdate(!0)})))),new obsidian.Setting(e).setName(t("URL_PREFIX_NAME")).setDesc(fragWithHTML(t("URL_PREFIX_DESC"))).addText((A=>A.setPlaceholder(t("INSERT_EMOJI")).setValue(this.plugin.settings.urlPrefix).onChange((async A=>{this.plugin.settings.urlPrefix=A,this.applySettingsUpdate(!0)})))),new obsidian.Setting(e).setName(t("LINKOPACITY_NAME")).setDesc(fragWithHTML(t("LINKOPACITY_DESC"))).addSlider((A=>A.setLimits(0,1,.05).setValue(this.plugin.settings.linkOpacity).onChange((async A=>{r.innerText=` ${A.toString()}`,this.plugin.settings.linkOpacity=A,this.applySettingsUpdate(!0)})))).settingEl.createDiv("",(A=>{r=A,A.style.minWidth="2.3em",A.style.textAlign="right",A.innerText=` ${this.plugin.settings.linkOpacity.toString()}`})),new obsidian.Setting(e).setName(t("HOVERPREVIEW_NAME")).setDesc(fragWithHTML(t("HOVERPREVIEW_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.hoverPreviewWithoutCTRL).onChange((async A=>{this.plugin.settings.hoverPreviewWithoutCTRL=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("LINK_CTRL_CLICK_NAME")).setDesc(fragWithHTML(t("LINK_CTRL_CLICK_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.allowCtrlClick).onChange((async A=>{this.plugin.settings.allowCtrlClick=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("TRANSCLUSION_WRAP_NAME")).setDesc(fragWithHTML(t("TRANSCLUSION_WRAP_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.forceWrap).onChange((async A=>{this.plugin.settings.forceWrap=A,this.applySettingsUpdate(!0)})))).descEl.innerHTML=`![[doc#^ref]]{number} ${t("TRANSCLUSION_WRAP_DESC")}`,new obsidian.Setting(e).setName(t("PAGE_TRANSCLUSION_CHARCOUNT_NAME")).setDesc(fragWithHTML(t("PAGE_TRANSCLUSION_CHARCOUNT_DESC"))).addText((A=>A.setPlaceholder("Enter a number").setValue(this.plugin.settings.pageTransclusionCharLimit.toString()).onChange((async e=>{const t=parseInt(e);if(isNaN(t)&&""!==e)A.setValue(this.plugin.settings.pageTransclusionCharLimit.toString());else{if(this.requestEmbedUpdate=!0,""===e)return this.plugin.settings.pageTransclusionCharLimit=10,void this.applySettingsUpdate(!0);this.plugin.settings.pageTransclusionCharLimit=t,A.setValue(this.plugin.settings.pageTransclusionCharLimit.toString()),this.applySettingsUpdate(!0)}})))),new obsidian.Setting(e).setName(t("TRANSCLUSION_DEFAULT_WRAP_NAME")).setDesc(fragWithHTML(t("TRANSCLUSION_DEFAULT_WRAP_DESC"))).addText((A=>A.setPlaceholder("Enter a number").setValue(this.plugin.settings.wordWrappingDefault.toString()).onChange((async e=>{const t=parseInt(e);if(isNaN(t)&&""!==e)A.setValue(this.plugin.settings.wordWrappingDefault.toString());else{if(this.requestEmbedUpdate=!0,""===e)return this.plugin.settings.wordWrappingDefault=0,void this.applySettingsUpdate(!0);this.plugin.settings.wordWrappingDefault=t,A.setValue(this.plugin.settings.wordWrappingDefault.toString()),this.applySettingsUpdate(!0)}})))),new obsidian.Setting(e).setName(t("GET_URL_TITLE_NAME")).setDesc(fragWithHTML(t("GET_URL_TITLE_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.iframelyAllowed).onChange((async A=>{this.plugin.settings.iframelyAllowed=A,this.applySettingsUpdate()})))),this.containerEl.createEl("h1",{text:t("MD_HEAD")}),this.containerEl.createEl("p",{text:t("MD_HEAD_DESC")}),new obsidian.Setting(e).setName(t("MD_TRANSCLUDE_WIDTH_NAME")).setDesc(fragWithHTML(t("MD_TRANSCLUDE_WIDTH_DESC"))).addText((A=>A.setPlaceholder("Enter a number e.g. 500").setValue(this.plugin.settings.mdSVGwidth.toString()).onChange((async e=>{const t=parseInt(e);if(isNaN(t)&&""!==e)A.setValue(this.plugin.settings.mdSVGwidth.toString());else{if(this.requestEmbedUpdate=!0,""===e)return this.plugin.settings.mdSVGwidth=500,void this.applySettingsUpdate(!0);this.plugin.settings.mdSVGwidth=t,this.requestReloadDrawings=!0,A.setValue(this.plugin.settings.mdSVGwidth.toString()),this.applySettingsUpdate(!0)}})))),new obsidian.Setting(e).setName(t("MD_TRANSCLUDE_HEIGHT_NAME")).setDesc(fragWithHTML(t("MD_TRANSCLUDE_HEIGHT_DESC"))).addText((A=>A.setPlaceholder("Enter a number e.g. 800").setValue(this.plugin.settings.mdSVGmaxHeight.toString()).onChange((async e=>{const t=parseInt(e);if(isNaN(t)&&""!==e)A.setValue(this.plugin.settings.mdSVGmaxHeight.toString());else{if(this.requestEmbedUpdate=!0,""===e)return this.plugin.settings.mdSVGmaxHeight=800,void this.applySettingsUpdate(!0);this.plugin.settings.mdSVGmaxHeight=t,this.requestReloadDrawings=!0,A.setValue(this.plugin.settings.mdSVGmaxHeight.toString()),this.applySettingsUpdate(!0)}})))),new obsidian.Setting(e).setName(t("MD_DEFAULT_FONT_NAME")).setDesc(fragWithHTML(t("MD_DEFAULT_FONT_DESC"))).addDropdown((async A=>{A.addOption("Virgil","Virgil"),A.addOption("Cascadia","Cascadia"),this.app.vault.getFiles().filter((A=>["ttf","woff","woff2"].contains(A.extension))).forEach((e=>{A.addOption(e.path,e.name)})),A.setValue(this.plugin.settings.mdFont).onChange((A=>{this.requestReloadDrawings=!0,this.plugin.settings.mdFont=A,this.applySettingsUpdate(!0)}))})),new obsidian.Setting(e).setName(t("MD_DEFAULT_COLOR_NAME")).setDesc(fragWithHTML(t("MD_DEFAULT_COLOR_DESC"))).addText((A=>A.setPlaceholder("CSS Color-name|RGB-HEX").setValue(this.plugin.settings.mdFontColor).onChange((A=>{this.requestReloadDrawings=!0,this.plugin.settings.mdFontColor=A,this.applySettingsUpdate(!0)})))),new obsidian.Setting(e).setName(t("MD_DEFAULT_BORDER_COLOR_NAME")).setDesc(fragWithHTML(t("MD_DEFAULT_BORDER_COLOR_DESC"))).addText((A=>A.setPlaceholder("CSS Color-name|RGB-HEX").setValue(this.plugin.settings.mdBorderColor).onChange((A=>{this.requestReloadDrawings=!0,this.plugin.settings.mdBorderColor=A,this.applySettingsUpdate(!0)})))),new obsidian.Setting(e).setName(t("MD_CSS_NAME")).setDesc(fragWithHTML(t("MD_CSS_DESC"))).addText((A=>A.setPlaceholder("filename of css file in vault").setValue(this.plugin.settings.mdCSS).onChange((A=>{this.requestReloadDrawings=!0,this.plugin.settings.mdCSS=A,this.applySettingsUpdate(!0)})))),this.containerEl.createEl("h1",{text:t("EMBED_HEAD")}),new obsidian.Setting(e).setName(t("EMBED_PREVIEW_SVG_NAME")).setDesc(fragWithHTML(t("EMBED_PREVIEW_SVG_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.displaySVGInPreview).onChange((async A=>{this.plugin.settings.displaySVGInPreview=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("EMBED_REUSE_EXPORTED_IMAGE_NAME")).setDesc(fragWithHTML(t("EMBED_REUSE_EXPORTED_IMAGE_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.displayExportedImageIfAvailable).onChange((async A=>{this.plugin.settings.displayExportedImageIfAvailable=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("PREVIEW_MATCH_OBSIDIAN_NAME")).setDesc(fragWithHTML(t("PREVIEW_MATCH_OBSIDIAN_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.previewMatchObsidianTheme).onChange((async A=>{this.plugin.settings.previewMatchObsidianTheme=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("EMBED_WIDTH_NAME")).setDesc(fragWithHTML(t("EMBED_WIDTH_DESC"))).addText((A=>A.setPlaceholder("400").setValue(this.plugin.settings.width).onChange((async A=>{this.plugin.settings.width=A,this.applySettingsUpdate(),this.requestEmbedUpdate=!0})))),new obsidian.Setting(e).setName(t("EMBED_TYPE_NAME")).setDesc(fragWithHTML(t("EMBED_TYPE_DESC"))).addDropdown((async A=>{o=A,o.addOption("excalidraw","excalidraw"),this.plugin.settings.autoexportPNG?o.addOption("PNG","PNG"):"PNG"===this.plugin.settings.embedType&&(this.plugin.settings.embedType="excalidraw",this.applySettingsUpdate()),this.plugin.settings.autoexportSVG?o.addOption("SVG","SVG"):"SVG"===this.plugin.settings.embedType&&(this.plugin.settings.embedType="excalidraw",this.applySettingsUpdate()),o.setValue(this.plugin.settings.embedType).onChange((async A=>{this.plugin.settings.embedType=A,this.applySettingsUpdate()}))})),new obsidian.Setting(e).setName(t("EMBED_WIKILINK_NAME")).setDesc(fragWithHTML(t("EMBED_WIKILINK_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.embedWikiLink).onChange((async A=>{this.plugin.settings.embedWikiLink=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("EXPORT_PNG_SCALE_NAME")).setDesc(fragWithHTML(t("EXPORT_PNG_SCALE_DESC"))).addSlider((A=>A.setLimits(1,5,.5).setValue(this.plugin.settings.pngExportScale).onChange((async A=>{l.innerText=` ${A.toString()}`,this.plugin.settings.pngExportScale=A,this.applySettingsUpdate()})))).settingEl.createDiv("",(A=>{l=A,A.style.minWidth="2.3em",A.style.textAlign="right",A.innerText=` ${this.plugin.settings.pngExportScale.toString()}`})),new obsidian.Setting(e).setName(t("EXPORT_BACKGROUND_NAME")).setDesc(fragWithHTML(t("EXPORT_BACKGROUND_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.exportWithBackground).onChange((async A=>{this.plugin.settings.exportWithBackground=A,this.applySettingsUpdate(),this.requestEmbedUpdate=!0})))),new obsidian.Setting(e).setName(t("EXPORT_SVG_PADDING_NAME")).setDesc(fragWithHTML(t("EXPORT_SVG_PADDING_DESC"))).addSlider((A=>A.setLimits(0,50,5).setValue(this.plugin.settings.exportPaddingSVG).onChange((async A=>{c.innerText=` ${A.toString()}`,this.plugin.settings.exportPaddingSVG=A,this.applySettingsUpdate()})))).settingEl.createDiv("",(A=>{c=A,A.style.minWidth="2.3em",A.style.textAlign="right",A.innerText=` ${this.plugin.settings.exportPaddingSVG.toString()}`})),new obsidian.Setting(e).setName(t("EXPORT_THEME_NAME")).setDesc(fragWithHTML(t("EXPORT_THEME_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.exportWithTheme).onChange((async A=>{this.plugin.settings.exportWithTheme=A,this.applySettingsUpdate(),this.requestEmbedUpdate=!0})))),this.containerEl.createEl("h1",{text:t("EXPORT_HEAD")}),new obsidian.Setting(e).setName(t("EXPORT_SYNC_NAME")).setDesc(fragWithHTML(t("EXPORT_SYNC_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.keepInSync).onChange((async A=>{this.plugin.settings.keepInSync=A,this.applySettingsUpdate()}))));const d=A=>{let e=0;for(e=0;eA.setValue(this.plugin.settings.autoexportSVG).onChange((async A=>{A?o.addOption("SVG","SVG"):("SVG"===this.plugin.settings.embedType&&(o.setValue("excalidraw"),this.plugin.settings.embedType="excalidraw"),d("SVG")),this.plugin.settings.autoexportSVG=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("EXPORT_PNG_NAME")).setDesc(fragWithHTML(t("EXPORT_PNG_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.autoexportPNG).onChange((async A=>{A?o.addOption("PNG","PNG"):("PNG"===this.plugin.settings.embedType&&(o.setValue("excalidraw"),this.plugin.settings.embedType="excalidraw"),d("PNG")),this.plugin.settings.autoexportPNG=A,this.applySettingsUpdate()})))),this.containerEl.createEl("h1",{text:t("COMPATIBILITY_HEAD")}),new obsidian.Setting(e).setName(t("COMPATIBILITY_MODE_NAME")).setDesc(fragWithHTML(t("COMPATIBILITY_MODE_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.compatibilityMode).onChange((async A=>{this.plugin.settings.compatibilityMode=A,a.innerHTML=n(),this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("EXPORT_EXCALIDRAW_NAME")).setDesc(fragWithHTML(t("EXPORT_EXCALIDRAW_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.autoexportExcalidraw).onChange((async A=>{this.plugin.settings.autoexportExcalidraw=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("SYNC_EXCALIDRAW_NAME")).setDesc(fragWithHTML(t("SYNC_EXCALIDRAW_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.syncExcalidraw).onChange((async A=>{this.plugin.settings.syncExcalidraw=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("MATHJAX_NAME")).setDesc(t("MATHJAX_DESC")).addDropdown((A=>{A.addOption("https://cdn.jsdelivr.net/npm/mathjax@3.2.1/es5/tex-svg.js","jsdelivr").addOption("https://unpkg.com/mathjax@3.2.1/es5/tex-svg.js","unpkg").addOption("https://cdnjs.cloudflare.com/ajax/libs/mathjax/3.2.1/es5/tex-svg-full.min.js","cdnjs").setValue(this.plugin.settings.mathjaxSourceURL).onChange((A=>{this.plugin.settings.mathjaxSourceURL=A,this.reloadMathJax=!0,this.applySettingsUpdate()}))})),this.containerEl.createEl("h1",{text:t("EXPERIMENTAL_HEAD")}),this.containerEl.createEl("p",{text:t("EXPERIMENTAL_DESC")}),new obsidian.Setting(e).setName(t("FIELD_SUGGESTER_NAME")).setDesc(fragWithHTML(t("FIELD_SUGGESTER_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.fieldSuggester).onChange((async A=>{this.plugin.settings.fieldSuggester=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("FILETYPE_NAME")).setDesc(fragWithHTML(t("FILETYPE_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.experimentalFileType).onChange((async A=>{this.plugin.settings.experimentalFileType=A,this.plugin.experimentalFileTypeDisplayToggle(A),this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("FILETAG_NAME")).setDesc(fragWithHTML(t("FILETAG_DESC"))).addText((A=>A.setPlaceholder(t("INSERT_EMOJI")).setValue(this.plugin.settings.experimentalFileTag).onChange((async A=>{this.plugin.settings.experimentalFileTag=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("LIVEPREVIEW_NAME")).setDesc(fragWithHTML(t("LIVEPREVIEW_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.experimentalLivePreview).onChange((async A=>{this.plugin.settings.experimentalLivePreview=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("ENABLE_FOURTH_FONT_NAME")).setDesc(fragWithHTML(t("ENABLE_FOURTH_FONT_DESC"))).addToggle((A=>A.setValue(this.plugin.settings.experimentalEnableFourthFont).onChange((async A=>{this.requestReloadDrawings=!0,this.plugin.settings.experimentalEnableFourthFont=A,this.applySettingsUpdate()})))),new obsidian.Setting(e).setName(t("FOURTH_FONT_NAME")).setDesc(fragWithHTML(t("FOURTH_FONT_DESC"))).addDropdown((async A=>{A.addOption("Virgil","Virgil"),this.app.vault.getFiles().filter((A=>["ttf","woff","woff2"].contains(A.extension))).forEach((e=>{A.addOption(e.path,e.name)})),A.setValue(this.plugin.settings.experimantalFourthFont).onChange((A=>{this.requestReloadDrawings=!0,this.plugin.settings.experimantalFourthFont=A,this.applySettingsUpdate(!0),this.plugin.initializeFourthFont()}))}));const h=null===(A=this.plugin.scriptEngine.getListofScripts())||void 0===A?void 0:A.map((A=>this.plugin.scriptEngine.getScriptName(A)));if(Object.keys(this.plugin.settings.scriptEngineSettings).length>0&&h){const A=(A,e)=>{const t=this.plugin.settings.scriptEngineSettings[A][e];return"object"==typeof t?t.height:null},i=(A,e)=>{const t=this.plugin.settings.scriptEngineSettings[A][e];return"object"==typeof t?t.value:t},n=(A,e,t)=>{"object"==typeof this.plugin.settings.scriptEngineSettings[A][e]?this.plugin.settings.scriptEngineSettings[A][e].value=t:this.plugin.settings.scriptEngineSettings[A][e]=t},a=(A,t,a)=>{new obsidian.Setting(e).setName(t).setDesc(fragWithHTML(null!=a?a:"")).addToggle((e=>e.setValue(i(A,t)).onChange((async e=>{n(A,t,e),this.applySettingsUpdate()}))))},s=(t,a,s,r)=>{r&&"[object Array]"===Object.prototype.toString.call(r)&&r.length>0?new obsidian.Setting(e).setName(a).setDesc(fragWithHTML(null!=s?s:"")).addDropdown((A=>{r.forEach((e=>A.addOption(e.toString(),e.toString()))),A.setValue(i(t,a)).onChange((async A=>{n(t,a,A),this.applySettingsUpdate()}))})):A(t,a)?new obsidian.Setting(e).setName(a).setDesc(fragWithHTML(null!=s?s:"")).addTextArea((e=>{e.inputEl.style.minHeight=A(t,a),e.inputEl.style.minWidth="400px",e.setValue(i(t,a)).onChange((async A=>{n(t,a,A),this.applySettingsUpdate()}))})):new obsidian.Setting(e).setName(a).setDesc(fragWithHTML(null!=s?s:"")).addText((A=>A.setValue(i(t,a)).onChange((async A=>{n(t,a,A),this.applySettingsUpdate()}))))},r=(A,t,a)=>{new obsidian.Setting(e).setName(t).setDesc(fragWithHTML(null!=a?a:"")).addText((e=>e.setPlaceholder("Enter a number").setValue(i(A,t).toString()).onChange((async a=>{const s=parseFloat(a);isNaN(s)&&""!==a?e.setValue(i(A,t).toString()):(n(A,t,isNaN(s)?0:s),this.applySettingsUpdate())}))))};this.containerEl.createEl("h1",{text:t("SCRIPT_SETTINGS_HEAD")}),Object.keys(this.plugin.settings.scriptEngineSettings).filter((A=>h.contains(A))).forEach((A=>{const e=this.plugin.settings.scriptEngineSettings[A],t=Object.values(e);0===t.length||t.length>0&&0===t.map((A=>A.hidden?0:1)).reduce(((A,e)=>A+e))||(this.containerEl.createEl("h3",{text:A}),Object.keys(e).forEach((t=>{var i;const n=e[t];switch(typeof(null!==(i=n.value)&&void 0!==i?i:n)){case"boolean":n.hidden||a(A,t,n.description);break;case"string":n.hidden||s(A,t,n.description,n.valueset);break;case"number":n.hidden||r(A,t,n.description)}})))}))}}}var openDialogAction;!function(A){A[A.openFile=0]="openFile",A[A.insertLinkToDrawing=1]="insertLinkToDrawing"}(openDialogAction||(openDialogAction={}));class OpenFileDialog extends obsidian.FuzzySuggestModal{constructor(A,e){super(A),this.app=A,this.action=openDialogAction.openFile,this.plugin=e,this.onNewPane=!1,this.limit=20,this.setInstructions([{command:t("TYPE_FILENAME"),purpose:""}]),this.inputEl.onkeyup=A=>{"Enter"==A.key&&this.action==openDialogAction.openFile&&this.containerEl.innerText.includes(EMPTY_MESSAGE)&&(this.plugin.createAndOpenDrawing(`${this.plugin.settings.folder}/${this.inputEl.value}.excalidraw.md`,this.onNewPane?"new-pane":"active-pane"),this.close())}}getItems(){return(this.app.vault.getFiles()||[]).filter((A=>this.plugin.isExcalidrawFile(A)))}getItemText(A){return A.path}onChooseItem(A){switch(this.action){case openDialogAction.openFile:this.plugin.openDrawing(A,this.onNewPane?"new-pane":"active-pane");break;case openDialogAction.insertLinkToDrawing:this.plugin.embedDrawing(A)}}start(A,e){switch(this.action=A,this.onNewPane=e,A){case openDialogAction.openFile:this.emptyStateText=EMPTY_MESSAGE,this.setPlaceholder(t("SELECT_FILE_OR_TYPE_NEW"));break;case openDialogAction.insertLinkToDrawing:this.emptyStateText=t("NO_MATCH"),this.setPlaceholder(t("SELECT_TO_EMBED"))}this.open()}}class InsertLinkDialog extends obsidian.FuzzySuggestModal{constructor(A){super(A),this.app=A,this.limit=20,this.setInstructions([{command:t("SELECT_FILE"),purpose:""}]),this.setPlaceholder(t("SELECT_FILE_TO_LINK")),this.emptyStateText=t("NO_MATCH")}getItems(){return this.app.metadataCache.getLinkSuggestions().filter((A=>!A.path.match(REG_LINKINDEX_INVALIDCHARS)))}getItemText(A){return A.path+(A.alias?`|${A.alias}`:"")}onChooseItem(A){let e=A.path;A.file&&(e=this.app.metadataCache.fileToLinktext(A.file,this.drawingPath,!0)),this.addText(`[[${e+(A.alias?`|${A.alias}`:"")}]]`)}start(A,e){this.addText=e,this.drawingPath=A,this.open()}}class InsertImageDialog extends obsidian.FuzzySuggestModal{constructor(A){super(A.app),this.plugin=A,this.app=A.app,this.limit=20,this.setInstructions([{command:t("SELECT_FILE"),purpose:""}]),this.setPlaceholder(t("SELECT_DRAWING")),this.emptyStateText=t("NO_MATCH")}getItems(){return(this.app.vault.getFiles()||[]).filter((A=>(IMAGE_TYPES.contains(A.extension)||this.plugin.isExcalidrawFile(A))&&!A.path.match(REG_LINKINDEX_INVALIDCHARS)))}getItemText(A){return A.path}onChooseItem(A){const e=this.plugin.ea;e.reset(),e.setView(this.view),e.canvas.theme=this.view.excalidrawAPI.getAppState().theme,(async()=>{await e.addImage(0,0,A),e.addElementsToView(!0,!1,!0)})()}start(A){this.view=A,this.open()}}class InsertMDDialog extends obsidian.FuzzySuggestModal{constructor(A){super(A.app),this.plugin=A,this.app=A.app,this.limit=20,this.setInstructions([{command:t("SELECT_FILE"),purpose:""}]),this.setPlaceholder(t("SELECT_MD")),this.emptyStateText=t("NO_MATCH")}getItems(){return(this.app.vault.getFiles()||[]).filter((A=>"md"===A.extension&&!this.plugin.isExcalidrawFile(A)))}getItemText(A){return A.path}onChooseItem(A){const e=this.plugin.ea;e.reset(),e.setView(this.view),(async()=>{await e.addImage(0,0,A),e.addElementsToView(!0,!1,!0)})()}start(A){this.view=A,this.open()}}function around(A,e){const t=Object.keys(e).map((t=>around1(A,t,e[t])));return 1===t.length?t[0]:function(){t.forEach((A=>A()))}}function around1(A,e,t){const i=A[e],n=A.hasOwnProperty(e);let a=t(i);return i&&Object.setPrototypeOf(a,i),Object.setPrototypeOf(s,a),A[e]=s,r;function s(...t){return a===i&&A[e]===s&&r(),a.apply(this,t)}function r(){A[e]===s&&(n?A[e]=i:delete A[e]),a!==i&&(a=i,Object.setPrototypeOf(s,i||Function))}}let plugin,vault,metadataCache;const getDefaultWidth=A=>{const e=parseInt(A.settings.width);return isNaN(e)||0===e||null===e?"400":A.settings.width},initializeMarkdownPostProcessor=A=>{plugin=A,vault=A.app.vault,metadataCache=A.app.metadataCache},getIMG=async A=>{var e;let t=A.file;if(!A.file){const e=vault.getAbstractFileByPath(A.fname);if(!(e&&e instanceof obsidian.TFile))return null;t=e}A.style=A.style.replaceAll(" ","-");const i=hasExportTheme(plugin,t)?getExportTheme(plugin,t,"light"):void 0,n={withBackground:getWithBackground(plugin,t),withTheme:!!i||plugin.settings.exportWithTheme},a=createEl("img");let s=`max-width:${A.fwidth}px !important; width:100%;`;A.fheight&&(s+=`height:${A.fheight}px;`),a.setAttribute("style",s),a.addClass(A.style);const r=null!=i?i:plugin.settings.previewMatchObsidianTheme?isObsidianThemeDark()?"dark":"light":plugin.settings.exportWithTheme?void 0:"light";r&&(n.withTheme=!0);const o=new EmbeddedFilesLoader(plugin,r?"dark"===r:void 0);if(!plugin.settings.displaySVGInPreview){const i=parseInt(A.fwidth);let s=1;i>=600&&(s=2),i>=1200&&(s=3),i>=1800&&(s=4),i>=2400&&(s=5);const l=null!==(e=await getQuickImagePreview(plugin,t.path,"png"))&&void 0!==e?e:await createPNG(t.path,s,n,o,r,null,null,[],plugin,0);return l?(a.src=URL.createObjectURL(l),a):null}const l=await getQuickImagePreview(plugin,t.path,"svg");if(l)return a.setAttribute("src",svgToBase64(l)),a;const c=(await createSVG(t.path,!0,n,o,r,null,null,[],plugin,0,getSVGPadding(plugin,t))).outerHTML;let d=null;const h=document.createElement("div");h.innerHTML=c;const g=h.firstChild;return g instanceof SVGSVGElement&&(d=g),d?(d=embedFontsInSVG(d,plugin),d.removeAttribute("width"),d.removeAttribute("height"),a.setAttribute("src",svgToBase64(d.outerHTML)),a):null},createImageDiv=async A=>{const e=await getIMG(A);return createDiv(A.style,(t=>{t.append(e),t.setAttribute("src",A.file.path),A.fwidth&&t.setAttribute("w",A.fwidth),A.fheight&&t.setAttribute("h",A.fheight),t.onClickEvent((A=>{if(A.target instanceof Element&&"img"!=A.target.tagName.toLowerCase())return;const e=t.getAttribute("src");e&&plugin.openDrawing(vault.getAbstractFileByPath(e),A[CTRL_OR_CMD]?"new-pane":A.metaKey&&!app.isMobile?"popout-window":"active-pane")})),t.addEventListener(RERENDER_EVENT,(async A=>{A.stopPropagation(),t.empty();const e=await getIMG({fname:t.getAttribute("src"),fwidth:t.getAttribute("w"),fheight:t.getAttribute("h"),style:t.getAttribute("class")});t.append(e)}))}))},processInternalEmbeds=async(A,e)=>{var t;const i={fname:"",fheight:"",fwidth:"",style:""};let n,a,s;for(const r of A)if(i.fname=r.getAttribute("src"),s=metadataCache.getFirstLinkpathDest(null===(t=i.fname)||void 0===t?void 0:t.split("#")[0],e.sourcePath),s&&s instanceof obsidian.TFile&&plugin.isExcalidrawFile(s)){i.fwidth=r.getAttribute("width")?r.getAttribute("width"):getDefaultWidth(plugin),i.fheight=r.getAttribute("height"),n=r.getAttribute("alt"),n==i.fname&&(n=""),i.style="excalidraw-svg",n&&("span"==r.tagName.toLowerCase()&&(n=`|${n}`),a=n.match(/[^\|]*\|?(\d*%?)x?(\d*%?)\|?(.*)/),i.fwidth=a[1]?a[1]:getDefaultWidth(plugin),i.fheight=a[2],a[3]!=i.fname&&(i.style="excalidraw-svg"+(a[3]?`-${a[3]}`:""))),i.fname=null==s?void 0:s.path,i.file=s;const A=await createImageDiv(i);r.parentElement.replaceChild(A,r)}},tmpObsidianWYSIWYG=async(A,e)=>{if(!e.frontmatter)return;if(!e.frontmatter.hasOwnProperty("excalidraw-plugin"))return;if(e.remainingNestLevel<4)return;if(!A.querySelector(".frontmatter"))return void(A.style.display="none");const t={fname:e.sourcePath,fheight:"",fwidth:getDefaultWidth(plugin),style:"excalidraw-svg"};if(t.file=metadataCache.getFirstLinkpathDest(e.sourcePath,""),A.empty(),!plugin.settings.experimentalLivePreview)return void A.appendChild(await createImageDiv(t));const i=createDiv();A.appendChild(i),setTimeout((async()=>{let e=i;for(;!e.hasClass("internal-embed")&&e.parentElement;)e=e.parentElement;if(!e.hasClass("internal-embed"))return A.empty(),void A.appendChild(await createImageDiv(t));e.empty();const n=splitFolderAndFilename(t.fname).basename,a=()=>{const A=e.getAttribute("width")&&""!==e.getAttribute("width"),i=e.getAttribute("height")&&""!==e.getAttribute("height");A&&(t.fwidth=e.getAttribute("width")),i&&(t.fheight=e.getAttribute("height"));const a=e.getAttribute("alt"),s=a&&""!==a&&a!==n&&a!==e.getAttribute("src");if(s){const A=a.match(/(\d*%?)x?(\d*%?)\|?(.*)/);t.fwidth=A[1]?A[1]:getDefaultWidth(plugin),t.fheight=A[2],A[3]!=t.fname&&(t.style="excalidraw-svg"+(A[3]?`-${A[3]}`:""))}A||i||s||(t.fheight="",t.fwidth=getDefaultWidth(plugin),t.style="excalidraw-svg")},s=async()=>{a();const A=await createImageDiv(t);e.appendChild(A)};await s();let r=null;new MutationObserver((A=>{var t;["alt","width","height"].contains(null===(t=A[0])||void 0===t?void 0:t.attributeName)&&(r&&clearTimeout(r),r=setTimeout((()=>{r=null,a(),e.empty(),s()}),500))})).observe(e,{attributes:!0})}),300)},markdownPostProcessor=async(A,e)=>{var t;const i=A.querySelectorAll(".internal-embed");0!==i.length?(null===(t=e.frontmatter)||void 0===t?void 0:t.hasOwnProperty("excalidraw-plugin"))?A.style.display="none":await processInternalEmbeds(i,e):tmpObsidianWYSIWYG(A,e)},hoverEvent=A=>{A.linktext?(plugin.hover.linkText=A.linktext,plugin.hover.sourcePath=A.sourcePath):plugin.hover.linkText=null},observer=new MutationObserver((async A=>{if(0==A.length)return;if(!plugin.hover.linkText)return;const e=metadataCache.getFirstLinkpathDest(plugin.hover.linkText,plugin.hover.sourcePath?plugin.hover.sourcePath:"");if(!e)return;if(!(e instanceof obsidian.TFile))return;if("excalidraw"!==e.extension)return;const t=getIMGFilename(e.path,"svg"),i=vault.getAbstractFileByPath(t);if(i&&i instanceof obsidian.TFile)return;const n=getIMGFilename(e.path,"png"),a=vault.getAbstractFileByPath(n);if(a&&a instanceof obsidian.TFile)return;if(!plugin.hover.linkText)return;if(1!=A.length)return;if(1!=A[0].addedNodes.length)return;if("popover hover-popover file-embed is-loaded"!=!A[0].addedNodes[0].classNames)return;const s=A[0].addedNodes[0];s.empty();const r=await getIMG({file:e,fname:e.path,fwidth:"300",fheight:null,style:"excalidraw-svg"}),o=createDiv("",(async A=>{A.appendChild(r),A.setAttribute("src",e.path),A.onClickEvent((e=>{e.stopImmediatePropagation();const t=A.getAttribute("src");t&&plugin.openDrawing(vault.getAbstractFileByPath(t),e[CTRL_OR_CMD]?"new-pane":e.metaKey&&!app.isMobile?"popout-window":"active-pane")}))}));s.appendChild(o)})),EXCALIDRAW_AUTOMATE_INFO=[{field:"plugin",code:null,desc:"The ExcalidrawPlugin object",after:""},{field:"elementsDict",code:null,desc:"The {} dictionary object, contains the ExcalidrawElements currently edited in Automate indexed by el.id",after:'[""]'},{field:"imagesDict",code:null,desc:"the images files including DataURL, indexed by fileId",after:'[""]'},{field:"style.strokeColor",code:"[string]",desc:"A valid css color. See W3 School Colors for more.",after:""},{field:"style.backgroundColor",code:"[string]",desc:"A valid css color. See W3 School Colors for more.",after:""},{field:"style.angle",code:"[number]",desc:"Rotation of the object in radian",after:""},{field:"style.fillStyle",code:"[string]",desc:"'hachure' | 'cross-hatch' | 'solid'",after:""},{field:"style.strokeWidth",code:"[number]",desc:null,after:""},{field:"style.strokeStyle",code:"[string]",desc:"'solid' | 'dashed' | 'dotted'",after:""},{field:"style.roughness",code:"[number]",desc:"0:Architect\n1:Artist\n2:Cartoonist",after:""},{field:"style.opacity",code:"[number]",desc:"100: Fully opaque\n0: Fully transparent",after:""},{field:"style.strokeSharpness",code:"[string]",desc:"'round' | 'sharp'",after:""},{field:"style.fontFamily",code:"[number]",desc:"1: Virgil, 2:Helvetica, 3:Cascadia, 4:LocalFont",after:""},{field:"style.fontSize",code:"[number]",desc:null,after:""},{field:"style.textAlign",code:"[string]",desc:"'left' | 'right' | 'center'",after:""},{field:"style.verticalAlign",code:"[string]",desc:"For future use, has no effect currently; 'top' | 'bottom' | 'middle'",after:""},{field:"style.startArrowHead",code:"[string]",desc:"'triangle' | 'dot' | 'arrow' | 'bar' | null",after:""},{field:"style.endArrowHead",code:"[string]",desc:"'triangle' | 'dot' | 'arrow' | 'bar' | null",after:""},{field:"canvas.theme",code:"[string]",desc:"'dark' | 'light'",after:""},{field:"canvas.viewBackgroundColor",code:"[string]",desc:"A valid css color.\nSee W3 School Colors for more.",after:""},{field:"canvas.gridSize",code:"[number]",desc:null,after:""},{field:"addToGroup",code:"addToGroup(objectIds: []): string;",desc:null,after:""},{field:"toCliboard",code:"toClipboard(templatePath?: string): void;",desc:"Copies current elements using template to clipboard, ready to be pasted into an excalidraw canvas",after:""},{field:"getElements",code:"getElements(): ExcalidrawElement[];",desc:"Get all elements from ExcalidrawAutomate elementsDict",after:""},{field:"getElement",code:"getElement(id: string): ExcalidrawElement;",desc:"Get single element from ExcalidrawAutomate elementsDict",after:""},{field:"create",code:'create(params?: {filename?: string, foldername?: string, templatePath?: string, onNewPane?: boolean, frontmatterKeys?: { "excalidraw-plugin"?: "raw" | "parsed", "excalidraw-link-prefix"?: string, "excalidraw-link-brackets"?: boolean, "excalidraw-url-prefix"?: string,},}): Promise;',desc:"Create a drawing and save it to filename.\nIf filename is null: default filename as defined in Excalidraw settings.\nIf folder is null: default folder as defined in Excalidraw settings\n",after:""},{field:"createSVG",code:"createSVG(templatePath?: string, embedFont?: boolean, exportSettings?: ExportSettings, loader?: EmbeddedFilesLoader, theme?: string,): Promise;",desc:"Use ExcalidrawAutomate.getExportSettings(boolean,boolean) to create an ExportSettings object.\nUse ExcalidrawAutomate.getEmbeddedFilesLoader(boolean?) to create an EmbeddedFilesLoader object.",after:""},{field:"createPNG",code:"createPNG(templatePath?: string, scale?: number, exportSettings?: ExportSettings, loader?: EmbeddedFilesLoader, theme?: string,): Promise;",desc:"Use ExcalidrawAutomate.getExportSettings(boolean,boolean) to create an ExportSettings object.\nUse ExcalidrawAutomate.getEmbeddedFilesLoader(boolean?) to create an EmbeddedFilesLoader object.",after:""},{field:"wrapText",code:"wrapText(text: string, lineLen: number): string;",desc:null,after:""},{field:"addRect",code:"addRect(topX: number, topY: number, width: number, height: number): string;",desc:null,after:""},{field:"addDiamond",code:"addDiamond(topX: number, topY: number, width: number, height: number): string;",desc:null,after:""},{field:"addEllipse",code:"addEllipse(topX: number, topY: number, width: number, height: number): string;",desc:null,after:""},{field:"addBlob",code:"addBlob(topX: number, topY: number, width: number, height: number): string;",desc:null,after:""},{field:"addText",code:'addText(topX: number, topY: number, text: string, formatting?: {wrapAt?: number; width?: number; height?: number; textAlign?: string; box?: boolean | "box" | "blob" | "ellipse" | "diamond"; boxPadding?: number;}, id?: string,): string;',desc:"If box is !null, then text will be boxed\nThe function returns the id of the TextElement. If the text element is boxed i.e. it is a sticky note, then the id of the container object",after:""},{field:"addLine",code:"addLine(points: [[x: number, y: number]]): string;",desc:null,after:""},{field:"addArrow",code:"addArrow(points: [[x: number, y: number]], formatting?: { startArrowHead?: string; endArrowHead?: string; startObjectId?: string; endObjectId?: string;},): string;",desc:null,after:""},{field:"addImage",code:"addImage(topX: number, topY: number, imageFile: TFile): Promise;",desc:null,after:""},{field:"addLaTex",code:"addLaTex(topX: number, topY: number, tex: string): Promise;",desc:null,after:""},{field:"connectObjects",code:"connectObjects(objectA: string, connectionA: ConnectionPoint, objectB: string, connectionB: ConnectionPoint, formatting?: {numberOfPoints?: number; startArrowHead?: string; endArrowHead?: string; padding?: number;},): string;",desc:'type ConnectionPoint = "top" | "bottom" | "left" | "right" | null\nWhen null is passed as ConnectionPoint then Excalidraw will automatically decide\nnumberOfPoints is the number of points on the line. Default is 0 i.e. line will only have a start and end point.\nArrowHead: "triangle"|"dot"|"arrow"|"bar"|null',after:""},{field:"addLabelToLine",code:"addLabelToLine(lineId: string, label: string): string;",desc:"Adds a text label to a line or arrow. Currently only works with a simple straight 2-point (start & end) line",after:""},{field:"clear",code:"clear(): void;",desc:"Clears elementsDict and imagesDict only",after:""},{field:"reset",code:"reset(): void;",desc:"clear() + reset all style values to default",after:""},{field:"isExcalidrawFile",code:"isExcalidrawFile(f: TFile): boolean;",desc:"Returns true if MD file is an Excalidraw file",after:""},{field:"targetView",code:"targetView: ExcalidrawView;",desc:"The Obsidian view currently edited",after:""},{field:"setView",code:'setView(view: ExcalidrawView | "first" | "active"): ExcalidrawView;',desc:null,after:""},{field:"getExcalidrawAPI",code:"getExcalidrawAPI(): any;",desc:"Excalidraw API",after:""},{field:"getViewElements",code:"getViewElements(): ExcalidrawElement[];",desc:"Get elements in View",after:""},{field:"deleteViewElements",code:"deleteViewElements(el: ExcalidrawElement[]): boolean;",desc:null,after:""},{field:"getViewSelectedElement",code:"getViewSelectedElement(): ExcalidrawElement;",desc:"Get the selected element in the view, if more are selected, get the first",after:""},{field:"getViewSelectedElements",code:"getViewSelectedElements(): ExcalidrawElement[];",desc:null,after:""},{field:"getViewFileForImageElement",code:"getViewFileForImageElement(el: ExcalidrawElement): TFile | null;",desc:"Returns the TFile file handle for the image element",after:""},{field:"copyViewElementsToEAforEditing",code:"copyViewElementsToEAforEditing(elements: ExcalidrawElement[]): void;",desc:"Copies elements from view to elementsDict for editing",after:""},{field:"viewToggleFullScreen",code:"viewToggleFullScreen(forceViewMode?: boolean): void;",desc:null,after:""},{field:"connectObjectWithViewSelectedElement",code:"connectObjectWithViewSelectedElement(objectA: string, connectionA: ConnectionPoint, connectionB: ConnectionPoint, formatting?: {numberOfPoints?: number; startArrowHead?: string; endArrowHead?: string; padding?: number;},): boolean;",desc:"Connect an object to the selected element in the view\nSee tooltip for connectObjects for details",after:""},{field:"addElementsToView",code:"addElementsToView(repositionToCursor?: boolean, save?: boolean, newElementsOnTop?: boolean,): Promise;",desc:"Adds elements from elementsDict to the current view\nrepositionToCursor: default is false\nsave: default is true\nnewElementsOnTop: default is false, i.e. the new elements get to the bottom of the stack\nnewElementsOnTop controls whether elements created with ExcalidrawAutomate are added at the bottom of the stack or the top of the stack of elements already in the view\nNote that elements copied to the view with copyViewElementsToEAforEditing retain their position in the stack of elements in the view even if modified using EA",after:""},{field:"onDropHook",code:'onDropHook(data: {ea: ExcalidrawAutomate, event: React.DragEvent, draggable: any, type: "file" | "text" | "unknown", payload: {files: TFile[], text: string,}, excalidrawFile: TFile, view: ExcalidrawView, pointerPosition: { x: number, y: number},}): boolean;',desc:"If set Excalidraw will call this function onDrop events.\nA return of true will stop the default onDrop processing in Excalidraw.\n\ndraggable is the Obsidian draggable object\nfiles is the array of dropped files\nexcalidrawFile is the file receiving the drop event\nview is the excalidraw view receiving the drop.\npointerPosition is the pointer position on canvas at the time of drop.",after:""},{field:"mostRecentMarkdownSVG",code:"mostRecentMarkdownSVG: SVGSVGElement;",desc:"Markdown renderer will drop a copy of the most recent SVG here for debugging purposes",after:""},{field:"getEmbeddedFilesLoader",code:"getEmbeddedFilesLoader(isDark?: boolean): EmbeddedFilesLoader;",desc:"Utility function to generate EmbeddedFilesLoader object",after:""},{field:"getExportSettings",code:"getExportSettings(withBackground: boolean, withTheme: boolean,): ExportSettings;",desc:"Utility function to generate ExportSettings object",after:""},{field:"getBoundingBox",code:"getBoundingBox(elements: ExcalidrawElement[]): {topX: number, topY: number, width: number, height: number,};",desc:"Gets the bounding box of elements. The bounding box is the box encapsulating all of the elements completely.",after:""},{field:"getMaximumGroups",code:"getMaximumGroups(elements: ExcalidrawElement[]): ExcalidrawElement[][];",desc:"Elements grouped by the highest level groups",after:""},{field:"getLargestElement",code:"getLargestElement(elements: ExcalidrawElement[]): ExcalidrawElement;",desc:"Gets the largest element from a group. useful when a text element is grouped with a box, and you want to connect an arrow to the box",after:""},{field:"intersectElementWithLine",code:"intersectElementWithLine(element: ExcalidrawBindableElement, a: readonly [number, number], b: readonly [number, number], gap?: number,): Point[];",desc:"If gap is given, the element is inflated by this value.\nReturns 2 or 0 intersection points between line going through `a` and `b` and the `element`, in ascending order of distance from `a`.",after:""},{field:"getLargestElement",code:"getLargestElement(elements: ExcalidrawElement[]): ExcalidrawElement;",desc:"Gets the largest element from a group. useful when a text element is grouped with a box, and you want to connect an arrow to the box",after:""},{field:"activeScript",code:"activeScript: string;",desc:"Mandatory to set before calling the get and set ScriptSettings functions. Set automatically by the ScriptEngine\nSee for more details: Script Engine Help",after:""},{field:"getScriptSettings",code:"getScriptSettings(): {};",desc:"Returns script settings. Saves settings in plugin settings, under the activeScript key. See for more details: Script Engine Help",after:""},{field:"setScriptSettings",code:"setScriptSettings(settings: any): Promise;",desc:"Sets script settings.\nSee for more details: Script Engine Help",after:""},{field:"openFileInNewOrAdjacentLeaf",code:"openFileInNewOrAdjacentLeaf(file: TFile): WorkspaceLeaf;",desc:"Open a file in a new workspaceleaf or reuse an existing adjacent leaf depending on Excalidraw Plugin Settings",after:""},{field:"measureText",code:"measureText(text: string): { width: number; height: number };",desc:"Measures text size based on current style settings",after:""},{field:"verifyMinimumPluginVersion",code:"verifyMinimumPluginVersion(requiredVersion: string): boolean;",desc:'Returns true if plugin version is >= than required\nrecommended use:\nif(!ea.verifyMinimumPluginVersion || !ea.verifyMinimumPluginVersion("1.5.20")) {new Notice("message");return;}',after:""},{field:"selectElementsInView",code:"selectElementsInView(elements: ExcalidrawElement[]):void;",desc:"Elements provided will be set as selected in the targetView.",after:""},{field:"generateElementId",code:"generateElementId(): string;",desc:"Returns an 8 character long random id",after:""},{field:"cloneElement",code:"cloneElement(element: ExcalidrawElement): ExcalidrawElement;",desc:"Returns a clone of the element with a new element id",after:""},{field:"moveViewElementToZIndex",code:"moveViewElementToZIndex(elementId:number, newZIndex:number): void;",desc:"Moves the element to a specific position in the z-index",after:""},{field:"hexStringToRgb",code:"hexStringToRgb(color: string):number[];",desc:"Converts a HEX color to an RGB number array. #FF0000 to [255,0,0]",after:""},{field:"rgbToHexString",code:"rgbToHexString(color: number[]):string;",desc:"Converts an RGB number array to a HEX string. [255,0,0] to #FF0000",after:""},{field:"hslToRgb",code:"hslToRgb(color: number[]):number[];",desc:"Converts an HSL number array to an RGB number array. [0,100,50] to [255,0,0]",after:""},{field:"rgbToHsl",code:"rgbToHsl(color:number[]):number[];",desc:"Converts an RGB number array to an HSL number array. [255,0,0] to [0,100,50]",after:""},{field:"colorNameToHex",code:"colorNameToHex(color:string):string;",desc:"Converts a CSS color name to its HEX color equivalent. 'White' to #FFFFFF",after:""}],EXCALIDRAW_SCRIPTENGINE_INFO=[{field:"inputPrompt",code:"inputPrompt: (header: string, placeholder?: string, value?: string, buttons?: [{caption:string, action:Function}]);",desc:"Opens a prompt that asks for an input.\nReturns a string with the input.\nYou need to await the result of inputPrompt.\nbuttons.action(input: string) => string\nThe button action function will receive the actual input string. If action returns null, input will be unchanged. If action returns a string, input will receive that value when the promise is resolved. example:\nlet fileType = '';\nconst filename = await utils.inputPrompt (\n 'Filename',\n '',\n '',\n, [\n {\n caption: 'Markdown',\n action: ()=>{fileType='md';return;}\n },\n {\n caption: 'Excalidraw',\n action: ()=>{fileType='ex';return;}\n }\n ]\n);",after:""},{field:"suggester",code:"suggester: (displayItems: string[], items: any[], hint?: string, instructions?:Instruction[]);",desc:"Opens a suggester. Displays the displayItems and returns the corresponding item from items[]\nYou need to await the result of suggester.\nIf the user cancels (ESC), suggester will return undefined\nHint and instructions are optional\n\ninterface Instruction {command: string;purpose: string;}",after:""}],FRONTMATTER_KEYS_INFO=[{field:"plugin",code:null,desc:"Denotes an excalidraw file. If key is not present, the file will not be recognized as an Excalidarw file. Valid values are 'parsed' and 'raw'",after:": parsed"},{field:"link-prefix",code:null,desc:"Set custom prefix to denote text element containing a valid internal link. Set to empty string if you do not want to show a prefix",after:': "📍"'},{field:"url-prefix",code:null,desc:"Set custom prefix to denote text element containing a valid external link. Set to empty string if you do not want to show a prefix",after:': "🌐"'},{field:"link-brackets",code:null,desc:"Set to true, if you want to display [[square brackets]] around the links in Text Elements",after:": true"},{field:"default-mode",code:null,desc:"Specifies how Excalidraw should open by default. Valid values are: view|zen",after:": view"},{field:"linkbutton-opacity",code:null,desc:"The opacity of the blue link button in the top right of the element overriding the respective setting in plugin settings. Valid values are between 0 and 1, where 0 means the button is transparent.",after:": 0.5"},{field:"onload-script",code:null,desc:"The value of this field will be executed as javascript code using the Script Engine environment. Use this to initiate custom actions or logic when loading your drawing.",after:': "new Notice(`Hello World!\\n\\nFile: ${ea.targetView.file.basename}`);"'},{field:"font",code:null,desc:"This key applies to Markdown Embeds. You can control the appearance of the embedded markdown file on a file by file bases by adding the this frontmatter key to your markdown document. Valid values are: Virgil|Cascadia|font_file_name.extension",after:": Virgil"},{field:"font-color",code:null,desc:"This key applies to Markdown Embeds. You can control the appearance of the embedded markdown file on a file by file bases by adding the this frontmatter key to your markdown document. Valid values are: css-color-name|#HEXcolor|any-other-html-standard-format",after:": SteelBlue"},{field:"border-color",code:null,desc:"This key applies to Markdown Embeds. You can control the appearance of the embedded markdown file on a file by file bases by adding the this frontmatter key to your markdown document. Valid values are: css-color-name|#HEXcolor|any-other-html-standard-format",after:": SteelBlue"},{field:"css",code:null,desc:'This key applies to Markdown Embeds. You can control the appearance of the embedded markdown file on a file by file bases by adding the this front matter keys to your markdown document. Valid values are: "css-filename|css snippet"',after:': ""'},{field:"export-transparent",code:null,desc:"If this key is present it will override the default excalidraw embed and export setting. true == Transparent / false == with background",after:": true"},{field:"export-dark",code:null,desc:"If this key is present it will override the default excalidraw embed and export setting. true == Dark mode / false == light mode",after:": true"},{field:"export-svgpadding",code:null,desc:"If this key is present it will override the default excalidraw embed and export setting. This only affects export to SVG. Specify the export padding for the image.",after:": 5"},{field:"export-pngscale",code:null,desc:"If this key is present it will override the default excalidraw embed and export setting. This only affects export to PNG. Specify the export scale for the image. The typical range is between 0.5 and 5, but you can experiment with other values as well.",after:": 1"}];class FieldSuggester extends obsidian.EditorSuggest{constructor(A){super(A.app),this.getSuggestions=A=>{const e=A.query.toLowerCase();return("ea"===this.suggestType?EXCALIDRAW_AUTOMATE_INFO:"utils"===this.suggestType?EXCALIDRAW_SCRIPTENGINE_INFO:FRONTMATTER_KEYS_INFO).map((A=>A.field)).filter((A=>A.toLowerCase().includes(e)))},this.plugin=A}onTrigger(A,e,t){var i,n,a,s,r;if(this.plugin.settings.fieldSuggester){const t=e.getLine(A.line).substring(0,A.ch),o=null!==(s=null!==(n=null===(i=t.match(/^excalidraw-(.*)$/))||void 0===i?void 0:i[1])&&void 0!==n?n:null===(a=t.match(/(^ea|\Wea)\.([\w\.]*)$/))||void 0===a?void 0:a[2])&&void 0!==s?s:null===(r=t.match(/(^utils|\Wutils)\.([\w\.]*)$/))||void 0===r?void 0:r[2];if(void 0!==o)return this.suggestType=t.match(/^excalidraw-(.*)$/)?"excalidraw":t.match(/(^ea|\Wea)\.([\w\.]*)$/)?"ea":"utils",this.latestTriggerInfo={end:A,start:{ch:A.ch-o.length,line:A.line},query:o},this.latestTriggerInfo}return null}renderSuggestion(A,e){const t=A.replace("ea"===this.suggestType?"ea.":"utils"===this.suggestType?"utils.":"excalidraw-",""),i=("ea"===this.suggestType?EXCALIDRAW_AUTOMATE_INFO:"utils"===this.suggestType?EXCALIDRAW_SCRIPTENGINE_INFO:FRONTMATTER_KEYS_INFO).find((e=>e.field===A));e.createEl("b",{text:t}),e.createEl("br"),i.code&&e.createEl("code",{text:i.code}),i.desc&&e.createDiv("div",(A=>A.innerHTML=i.desc))}selectSuggestion(A){var e;const{context:t}=this;if(t){const i="ea"===this.suggestType?EXCALIDRAW_AUTOMATE_INFO:"utils"===this.suggestType?EXCALIDRAW_SCRIPTENGINE_INFO:FRONTMATTER_KEYS_INFO,n=`${A}${null===(e=i.find((e=>e.field===A)))||void 0===e?void 0:e.after}`;if(t.editor.replaceRange(n,this.latestTriggerInfo.start,this.latestTriggerInfo.end),this.latestTriggerInfo.start.ch===this.latestTriggerInfo.end.ch){const A=this.latestTriggerInfo.end;A.ch+=n.length,t.editor.setCursor(A)}}}}class ExcalidrawPlugin extends obsidian.Plugin{constructor(A,e){super(A,e),this.excalidrawFiles=new Set,this.excalidrawFileModes={},this._loaded=!1,this.activeExcalidrawView=null,this.lastActiveExcalidrawFilePath=null,this.hover={linkText:null,sourcePath:null},this.opencount=0,this.filesMaster=null,this.equationsMaster=null,this.mathjax=null,this.mathjaxDiv=null,this.mathjaxLoaderFinished=!1,this.fourthFontDef=VIRGIL_FONT,this.packageMap=new WeakMap,this.popScope=null,this.filesMaster=new Map,this.equationsMaster=new Map}getPackage(A){if(A===window)return{react:react,reactDOM:reactDOM,excalidrawLib:excalidrawLib};if(this.packageMap.has(A))return this.packageMap.get(A);const{react:e,reactDOM:t,excalidrawLib:i}=A.eval.call(A,`(function() {\n ${lzString.exports.decompressFromBase64(EXCALIDRAW_PACKAGES)};\n return {react:React,reactDOM:ReactDOM,excalidrawLib:ExcalidrawLib};\n })()`);return this.packageMap.set(A,{react:e,reactDOM:t,excalidrawLib:i}),{react:e,reactDOM:t,excalidrawLib:i}}async onload(){if(obsidian.addIcon(ICON_NAME,EXCALIDRAW_ICON),obsidian.addIcon("ScriptEngine",SCRIPTENGINE_ICON),obsidian.addIcon("disk",DISK_ICON),obsidian.addIcon("save-png",PNG_ICON),obsidian.addIcon("save-svg",SVG_ICON),await this.loadSettings(),this.addSettingTab(new ExcalidrawSettingTab(this.app,this)),this.ea=await initExcalidrawAutomate(this),this.registerView("excalidraw",(A=>new ExcalidrawView(A,this))),this.registerExtensions(["excalidraw"],"excalidraw"),this.addMarkdownPostProcessor(),this.registerInstallCodeblockProcessor(),this.addThemeObserver(),this.experimentalFileTypeDisplayToggle(this.settings.experimentalFileType),this.registerCommands(),this.registerEventListeners(),this.initializeFourthFont(),this.registerEditorSuggest(new FieldSuggester(this)),this.registerMonkeyPatches(),this.settings.showReleaseNotes){const A=this.settings.imageElementNotice;PLUGIN_VERSION>this.settings.previousRelease&&new ReleaseNotes(this.app,this,A?null:PLUGIN_VERSION).open()}this.switchToExcalidarwAfterLoad(),this.loadMathJax();const A=this;this.app.workspace.onLayoutReady((()=>{this.scriptEngine=new ScriptEngine(A)}))}initializeFourthFont(){this.app.workspace.onLayoutReady((async()=>{const A=await getFontDataURL(this.app,this.settings.experimantalFourthFont,"","LocalFont"),e=""===A.dataURL?VIRGIL_DATAURL:A.dataURL;this.fourthFontDef=A.fontDef;const t=new Set;app.workspace.iterateAllLeaves((A=>{const i=app.isMobile?document:A.view.containerEl.ownerDocument;if(!i)return;if(t.has(i))return;t.add(i);const n=i.createElement("style");n.id="local-font-stylesheet",n.textContent=`\n @font-face {\n font-family: 'LocalFont';\n src: url("${e}");\n font-display: swap;\n }\n `;const a=i.getElementById(n.id);i.head.appendChild(n),a&&i.head.removeChild(a),i.fonts.load("20px LocalFont")}))}))}loadMathJax(){const A=this;this.app.workspace.onLayoutReady((async()=>{await obsidian.loadMathJax();try{A.mathjaxDiv&&(document.body.removeChild(A.mathjaxDiv),A.mathjax=null,A.mathjaxLoaderFinished=!1),A.mathjaxDiv=document.body.createDiv(),A.mathjaxDiv.title="Excalidraw MathJax Support",A.mathjaxDiv.style.display="none";const e=A.mathjaxDiv.createEl("iframe");e.title="Excalidraw MathJax Support";const t=e.contentWindow.document,i=t.createElement("script");i.type="text/javascript",i.onload=()=>{const t=e.contentWindow;t.MathJax.startup.pagePromise.then((async()=>{const e=A.app.vault.getAbstractFileByPath("preamble.sty"),i=e&&e instanceof obsidian.TFile?await A.app.vault.read(e):null;try{i&&await t.MathJax.tex2svg(i)}catch(e){errorlog({where:A.loadMathJax,description:"Unexpected error while loading preamble.sty",error:e})}A.mathjax=t.MathJax,A.mathjaxLoaderFinished=!0}))},i.src=A.settings.mathjaxSourceURL,t.head.appendChild(i)}catch(e){new obsidian.Notice("Excalidraw: Error initializing LaTeX support"),A.mathjaxLoaderFinished=!0}}))}switchToExcalidarwAfterLoad(){const A=this;this.app.workspace.onLayoutReady((()=>{let e;for(e of A.app.workspace.getLeavesOfType("markdown"))e.view instanceof obsidian.MarkdownView&&A.isExcalidrawFile(e.view.file)&&(A.excalidrawFileModes[e.id||e.view.file.path]="excalidraw",A.setExcalidrawView(e))}))}registerInstallCodeblockProcessor(){const A=async(A,e)=>{let i=null;try{const A=e.parentElement.querySelector(`a[href="#${e.previousElementSibling.getAttribute("data-heading")}"]`);A.style.paddingRight="10px",i=A.parentElement.createEl("button",null,(A=>{A.setText(t("UPDATE_SCRIPT")),A.addClass("mod-cta"),A.style.backgroundColor="var(--interactive-success)",A.style.display="none"}))}catch(e){errorlog({where:"this.registerInstallCodeblockProcessor",source:A,error:e})}A=A.trim(),e.createEl("button",null,(async e=>{const n=A=>{switch(i&&(i.style.display="none"),A){case"CHECKING":e.setText(t("CHECKING_SCRIPT")),e.style.backgroundColor="var(--interactive-normal)";break;case"INSTALL":e.setText(t("INSTALL_SCRIPT")),e.style.backgroundColor="var(--interactive-accent)";break;case"UPTODATE":e.setText(t("UPTODATE_SCRIPT")),e.style.backgroundColor="var(--interactive-normal)";break;case"UPDATE":e.setText(t("UPDATE_SCRIPT")),e.style.backgroundColor="var(--interactive-success)",i&&(i.style.display=null);break;case"ERROR":e.setText(t("UNABLETOCHECK_SCRIPT")),e.style.backgroundColor="var(--interactive-normal)"}};e.addClass("mod-cta");let a=A;try{a=decodeURI(A)}catch(e){errorlog({where:"ExcalidrawPlugin.registerInstallCodeblockProcessor.codeblockProcessor.onClick",source:A,error:e})}const s=a.substring(a.lastIndexOf("/")+1),r=`${this.settings.scriptFolderPath}/Downloaded`,o=`${r}/${s}`,l=getIMGFilename(o,"svg");let c=this.app.vault.getAbstractFileByPath(o),d=this.app.vault.getAbstractFileByPath(l);if(n(c?"CHECKING":"INSTALL"),e.onclick=async()=>{const e=async(A,e,t)=>{const i=await obsidian.request({url:A});return!i||i.startsWith("404: Not Found")?null:(e?await this.app.vault.modify(e,i):(await checkAndCreateFolder(this.app.vault,r),e=await this.app.vault.create(t,i)),e)};try{if(c=await e(A,c,o),!c)throw n("ERROR"),"File not found";d=await e(getIMGFilename(A,"svg"),d,l),n("UPTODATE"),new obsidian.Notice(`Installed: ${c.basename}`)}catch(A){new obsidian.Notice(`Error installing script: ${s}`),errorlog({where:"ExcalidrawPlugin.registerInstallCodeblockProcessor.codeblockProcessor.onClick",error:A})}},i&&(i.onclick=e.onclick),!(c&&c instanceof obsidian.TFile))return;const h=new Map;JSON.parse(await obsidian.request({url:"https://raw.githubusercontent.com/zsviczian/obsidian-excalidraw-plugin/master/ea-scripts/directory-info.json"})).forEach((A=>h.set(A.fname,A.mtime)));const g=(A,e)=>{if(0===h.size||!h.has(A))return"ERROR";const t=h.get(A);return!e||t>e.stat.mtime?"UPDATE":"UPTODATE"},u=g(s,c),w=g(getIMGFilename(s,"svg"),d&&d instanceof obsidian.TFile?d:null);n("UPTODATE"===u&&"UPTODATE"===w||"UPTODATE"===u&&"ERROR"===w?"UPTODATE":"ERROR"===u?"ERROR":"UPDATE"===u||"UPDATE"===w?"UPDATE":"UPTODATE")}))};this.registerMarkdownCodeBlockProcessor(SCRIPT_INSTALL_CODEBLOCK,(async(e,t)=>{t.addEventListener(RERENDER_EVENT,(async i=>{i.stopPropagation(),t.empty(),A(e,t)})),A(e,t)}))}addMarkdownPostProcessor(){plugin=this,vault=this.app.vault,metadataCache=this.app.metadataCache,this.registerMarkdownPostProcessor(markdownPostProcessor),this.registerEvent(this.app.workspace.on("hover-link",hoverEvent)),this.observer=observer,this.observer.observe(document,{childList:!0,subtree:!0})}addThemeObserver(){this.themeObserver=new MutationObserver((async A=>{var e,t,i,n,a,s,r,o;if(!this.settings.matchThemeTrigger)return;if((null===(e=A[0])||void 0===e?void 0:e.oldValue)===(null===(i=null===(t=A[0])||void 0===t?void 0:t.target)||void 0===i?void 0:i.getAttribute("class")))return;if((null===(a=null===(n=A[0])||void 0===n?void 0:n.oldValue)||void 0===a?void 0:a.includes("theme-dark"))===(null===(o=null===(r=null===(s=A[0])||void 0===s?void 0:s.target)||void 0===r?void 0:r.classList)||void 0===o?void 0:o.contains("theme-dark")))return;const l=isObsidianThemeDark()?"dark":"light";this.app.workspace.getLeavesOfType("excalidraw").forEach((A=>{const e=A.view;e.file&&e.excalidrawRef&&e.setTheme(l)}))})),this.themeObserver.observe(document.body,{attributeOldValue:!0,attributeFilter:["class"]})}experimentalFileTypeDisplayToggle(A){A?this.experimentalFileTypeDisplay():(this.fileExplorerObserver&&this.fileExplorerObserver.disconnect(),this.fileExplorerObserver=null)}experimentalFileTypeDisplay(){const A=A=>{if(1!=A.childElementCount)return;const e=A.getAttribute("data-path");if(!e)return;const t=this.app.vault.getAbstractFileByPath(e);t&&t instanceof obsidian.TFile&&this.isExcalidrawFile(t)&&A.insertBefore(createDiv({cls:"nav-file-tag",text:this.settings.experimentalFileTag}),A.firstChild)};this.fileExplorerObserver=new MutationObserver((e=>{e.filter((A=>A.addedNodes.length>0)).forEach((e=>{e.addedNodes.forEach((e=>{e instanceof Element&&e.querySelectorAll(".nav-file-title").forEach(A)}))}))}));const e=this;this.app.workspace.onLayoutReady((()=>{document.querySelectorAll(".nav-file-title").forEach(A),e.fileExplorerObserver.observe(document.querySelector(".workspace"),{childList:!0,subtree:!0})}))}registerCommands(){this.openDialog=new OpenFileDialog(this.app,this),this.insertLinkDialog=new InsertLinkDialog(this.app),this.insertImageDialog=new InsertImageDialog(this),this.insertMDDialog=new InsertMDDialog(this),this.addRibbonIcon(ICON_NAME,t("CREATE_NEW"),(async A=>{this.createAndOpenDrawing(getDrawingFilename(this.settings),A[CTRL_OR_CMD]?"new-pane":"active-pane")})),this.registerEvent(this.app.workspace.on("file-menu",((A,e)=>{A.addItem((A=>{A.setTitle(t("CREATE_NEW")).setIcon(ICON_NAME).onClick((()=>{let A=e.path;e instanceof obsidian.TFile&&(A=obsidian.normalizePath(e.path.substr(0,e.path.lastIndexOf(e.name)))),this.createAndOpenDrawing(getDrawingFilename(this.settings),"active-pane",A)}))}))}))),this.registerEvent(this.app.workspace.on("file-menu",((A,e)=>{e instanceof obsidian.TFile&&"excalidraw"==e.extension&&A.addItem((A=>{A.setTitle(t("CONVERT_FILE_KEEP_EXT")).onClick((()=>{this.convertSingleExcalidrawToMD(e,!1,!1)}))}))}))),this.registerEvent(this.app.workspace.on("file-menu",((A,e)=>{e instanceof obsidian.TFile&&"excalidraw"==e.extension&&A.addItem((A=>{A.setTitle(t("CONVERT_FILE_REPLACE_EXT")).onClick((()=>{this.convertSingleExcalidrawToMD(e,!0,!0)}))}))}))),this.addCommand({id:"excalidraw-download-lib",name:t("DOWNLOAD_LIBRARY"),callback:this.exportLibrary}),this.addCommand({id:"excalidraw-open",name:t("OPEN_EXISTING_NEW_PANE"),callback:()=>{this.openDialog.start(openDialogAction.openFile,!0)}}),this.addCommand({id:"excalidraw-open-on-current",name:t("OPEN_EXISTING_ACTIVE_PANE"),callback:()=>{this.openDialog.start(openDialogAction.openFile,!1)}}),this.addCommand({id:"excalidraw-insert-transclusion",name:t("TRANSCLUDE"),checkCallback:A=>A?Boolean(this.app.workspace.getActiveViewOfType(obsidian.MarkdownView)):(this.openDialog.start(openDialogAction.insertLinkToDrawing,!1),!0)}),this.addCommand({id:"excalidraw-insert-last-active-transclusion",name:t("TRANSCLUDE_MOST_RECENT"),checkCallback:A=>{if(A)return Boolean(this.app.workspace.getActiveViewOfType(obsidian.MarkdownView))&&null!=this.lastActiveExcalidrawFilePath;const e=this.app.vault.getAbstractFileByPath(this.lastActiveExcalidrawFilePath);return e instanceof obsidian.TFile&&(this.embedDrawing(e),!0)}}),this.addCommand({id:"excalidraw-autocreate",name:t("NEW_IN_NEW_PANE"),callback:()=>{this.createAndOpenDrawing(getDrawingFilename(this.settings),"new-pane")}}),this.addCommand({id:"excalidraw-autocreate-on-current",name:t("NEW_IN_ACTIVE_PANE"),callback:()=>{this.createAndOpenDrawing(getDrawingFilename(this.settings),"active-pane")}}),this.addCommand({id:"excalidraw-autocreate-popout",name:t("NEW_IN_POPOUT_WINDOW"),callback:()=>{this.createAndOpenDrawing(getDrawingFilename(this.settings),"popout-window")}});const A=async A=>{const e=this.app.workspace.getActiveViewOfType(obsidian.MarkdownView);if(!e)return;const t=getEmbedFilename(e.file.basename,this.settings),i=this.settings.embedUseExcalidrawFolder?null:(await getAttachmentsFolderAndFilePath(this.app,e.file.path,t)).folder,n=await this.createDrawing(t,i);await this.embedDrawing(n),this.openDrawing(n,A)};this.addCommand({id:"excalidraw-autocreate-and-embed",name:t("NEW_IN_NEW_PANE_EMBED"),checkCallback:e=>e?Boolean(this.app.workspace.getActiveViewOfType(obsidian.MarkdownView)):(A("new-pane"),!0)}),this.addCommand({id:"excalidraw-autocreate-and-embed-on-current",name:t("NEW_IN_ACTIVE_PANE_EMBED"),checkCallback:e=>e?Boolean(this.app.workspace.getActiveViewOfType(obsidian.MarkdownView)):(A("active-pane"),!0)}),this.addCommand({id:"excalidraw-autocreate-and-embed-popout",name:t("NEW_IN_POPOUT_WINDOW_EMBED"),checkCallback:e=>e?Boolean(this.app.workspace.getActiveViewOfType(obsidian.MarkdownView)):(A("popout-window"),!0)}),this.addCommand({id:"export-svg",name:t("EXPORT_SVG"),checkCallback:A=>{if(A)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const e=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!e&&(e.saveSVG(),!0)}}),this.addCommand({id:"search-text",name:t("SEARCH"),checkCallback:A=>{if(A)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const e=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!e&&(search(e),!0)}}),this.addCommand({id:"fullscreen",name:t("TOGGLE_FULLSCREEN"),checkCallback:A=>{if(A)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const e=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!e&&(e.isFullscreen()?e.exitFullscreen():e.gotoFullscreen(),!0)}}),this.addCommand({id:"export-png",name:t("EXPORT_PNG"),checkCallback:A=>{if(A)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const e=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!e&&(e.savePNG(),!0)}}),this.addCommand({id:"toggle-lock",hotkeys:[{modifiers:["Ctrl","Shift"],key:"e"}],name:t("TOGGLE_LOCK"),checkCallback:A=>{if(A)return!!Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView))&&!this.app.workspace.getActiveViewOfType(ExcalidrawView).compatibilityMode;const e=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!e&&(e.changeTextMode(e.textMode===TextMode.parsed?TextMode.raw:TextMode.parsed),!0)}}),this.addCommand({id:"delete-file",name:t("DELETE_FILE"),checkCallback:A=>{if(A)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const e=this.app.workspace.getActiveViewOfType(ExcalidrawView);if(e){this.ea.reset(),this.ea.setView(e);const A=this.ea.getViewSelectedElement();if("image"!==A.type)return new obsidian.Notice("Please select an image or embedded markdown document",4e3),!0;const t=this.ea.getViewFileForImageElement(A);return t?(this.app.vault.delete(t),this.ea.deleteViewElements([A]),!0):(new obsidian.Notice("Please select an image or embedded markdown document",4e3),!0)}return!1}}),this.addCommand({id:"insert-link",hotkeys:[{modifiers:["Ctrl","Shift"],key:"k"}],name:t("INSERT_LINK"),checkCallback:A=>{if(A)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const e=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!e&&(this.insertLinkDialog.start(e.file.path,e.addText),!0)}}),this.addCommand({id:"insert-link-to-element",hotkeys:[{modifiers:["Ctrl","Shift"],key:"k"}],name:t("INSERT_LINK_TO_ELEMENT"),checkCallback:A=>{if(A)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const e=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!e&&(e.copyLinkToSelectedElementToClipboard(),!0)}}),this.addCommand({id:"insert-image",name:t("INSERT_IMAGE"),checkCallback:A=>{if(A)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const e=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!e&&(this.insertImageDialog.start(e),!0)}}),this.addCommand({id:"release-notes",name:t("READ_RELEASE_NOTES"),checkCallback:A=>A?Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView)):(new ReleaseNotes(this.app,this,PLUGIN_VERSION).open(),!0)}),this.addCommand({id:"tray-mode",name:t("TRAY_MODE"),checkCallback:A=>{if(A){const A=this.app.workspace.getActiveViewOfType(ExcalidrawView);if(!A||!A.excalidrawRef)return!1;const e=A.excalidrawAPI.getAppState();return!e.zenModeEnabled&&!e.viewModeEnabled}const e=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!(!e||!e.excalidrawAPI||(e.toggleTrayMode(),0))}}),this.addCommand({id:"insert-md",name:t("INSERT_MD"),checkCallback:A=>{if(A)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const e=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!e&&(this.insertMDDialog.start(e),!0)}}),this.addCommand({id:"insert-LaTeX-symbol",name:t("INSERT_LATEX"),checkCallback:A=>{if(A)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView));const e=this.app.workspace.getActiveViewOfType(ExcalidrawView);return!!e&&(insertLaTeXToView(e),!0)}}),this.addCommand({id:"toggle-excalidraw-view",name:t("TOGGLE_MODE"),checkCallback:A=>{const e=this.app.workspace.getActiveFile();if(!e)return!1;const t=this.isExcalidrawFile(e);if(A)return Boolean(this.app.workspace.getActiveViewOfType(ExcalidrawView))?!this.app.workspace.getActiveViewOfType(ExcalidrawView).compatibilityMode:t;const i=this.app.workspace.getActiveViewOfType(ExcalidrawView);if(i){const A=i.leaf;return this.excalidrawFileModes[A.id||e.path]="markdown",void this.setMarkdownView(A)}const n=this.app.workspace.getActiveViewOfType(obsidian.MarkdownView);if(n&&t){const A=n.leaf;return this.excalidrawFileModes[A.id||e.path]="excalidraw",void this.setExcalidrawView(A)}}}),this.addCommand({id:"convert-to-excalidraw",name:t("CONVERT_NOTE_TO_EXCALIDRAW"),checkCallback:A=>{const e=this.app.workspace.getActiveFile(),t=this.app.workspace.getActiveViewOfType(obsidian.MarkdownView);if(!e||!t)return!1;const i=0===e.stat.size;if(A)return i;i&&(async()=>{await this.app.vault.modify(e,await this.getBlankDrawing()),this.setExcalidrawView(t.leaf)})()}}),this.addCommand({id:"convert-excalidraw",name:t("CONVERT_EXCALIDRAW"),checkCallback:A=>A?this.app.vault.getFiles().filter((A=>"excalidraw"==A.extension)).length>0:(this.convertExcalidrawToMD(),!0)})}async convertSingleExcalidrawToMD(A,e=!1,t=!1){const i=await this.app.vault.read(A),n=A.name.substring(0,A.name.lastIndexOf(".excalidraw"))+(e?".md":".excalidraw.md"),a=getNewUniqueFilepath(this.app.vault,n,obsidian.normalizePath(A.path.substring(0,A.path.lastIndexOf(A.name))));log(a);const s=await this.app.vault.create(a,FRONTMATTER+await this.exportSceneToMD(i));return this.settings.keepInSync&&[".svg",".png"].forEach((e=>{const t=A.path.substring(0,A.path.lastIndexOf(".excalidraw"))+e,i=this.app.vault.getAbstractFileByPath(obsidian.normalizePath(t));if(i&&i instanceof obsidian.TFile){const A=a.substring(0,a.lastIndexOf(".md"))+e;this.app.fileManager.renameFile(i,A)}})),t||this.app.vault.delete(A),s}async convertExcalidrawToMD(A=!1,e=!1){const t=this.app.vault.getFiles().filter((A=>"excalidraw"==A.extension));for(const i of t)this.convertSingleExcalidrawToMD(i,A,e);new obsidian.Notice(`Converted ${t.length} files.`)}registerMonkeyPatches(){const A=this;this.register(around(obsidian.WorkspaceLeaf.prototype,{detach:e=>function(){var t;const i=null===(t=this.view)||void 0===t?void 0:t.getState();return(null==i?void 0:i.file)&&A.excalidrawFileModes[this.id||i.file]&&delete A.excalidrawFileModes[this.id||i.file],e.apply(this)},setViewState:e=>function(t,...i){var n;if(A._loaded&&"markdown"===t.type&&(null===(n=t.state)||void 0===n?void 0:n.file)&&"markdown"!==A.excalidrawFileModes[this.id||t.state.file]){const n=A.app.metadataCache.getCache(t.state.file);if((null==n?void 0:n.frontmatter)&&n.frontmatter[FRONTMATTER_KEY]){const n=Object.assign(Object.assign({},t),{type:"excalidraw"});return A.excalidrawFileModes[t.state.file]="excalidraw",e.apply(this,[n,...i])}}return e.apply(this,[t,...i])}})),this.register(around(obsidian.MarkdownView.prototype,{onPaneMenu:e=>function(i){const n=this.file,a=n?A.app.metadataCache.getFileCache(n):null;if(!n||!(null==a?void 0:a.frontmatter)||!a.frontmatter[FRONTMATTER_KEY])return e.call(this,i);i.addItem((e=>{e.setTitle(t("OPEN_AS_EXCALIDRAW")).setIcon(ICON_NAME).setSection("pane").onClick((()=>{A.excalidrawFileModes[this.leaf.id||n.path]="excalidraw",A.setExcalidrawView(this.leaf)}))})).addSeparator(),e.call(this,i)}}))}registerEventListeners(){const A=this;this.app.workspace.onLayoutReady((async()=>{A.registerEvent(A.app.vault.on("rename",(async(e,t)=>{e instanceof obsidian.TFile&&A.isExcalidrawFile(e)&&A.settings.keepInSync&&[".svg",".png",".excalidraw"].forEach((async i=>{const n=getIMGPathFromExcalidrawFile(t,i),a=A.app.vault.getAbstractFileByPath(obsidian.normalizePath(n));if(a&&a instanceof obsidian.TFile){const t=getIMGPathFromExcalidrawFile(e.path,i);await A.app.fileManager.renameFile(a,t)}}))}))),A.registerEvent(A.app.vault.on("modify",(async e=>{A.app.workspace.getLeavesOfType("excalidraw").forEach((async t=>{const i=t.view;if(i.file&&(i.file.path===e.path||"excalidraw"===e.extension&&`${e.path.substring(0,e.path.lastIndexOf(".excalidraw"))}.md`===i.file.path)){if(i.semaphores.preventReload)return void(i.semaphores.preventReload=!1);if(i.lastSaveTimestamp+3e5{if(!(e instanceof obsidian.TFile))return;const t=this.excalidrawFiles.has(e);if(this.updateFileCache(e,void 0,!0),!t)return;const i=A.app.workspace.getLeavesOfType("excalidraw");for(let A=0;A{[".svg",".png",".excalidraw"].forEach((async t=>{const i=getIMGPathFromExcalidrawFile(e.path,t),n=A.app.vault.getAbstractFileByPath(obsidian.normalizePath(i));n&&n instanceof obsidian.TFile&&await A.app.vault.delete(n)}))}),500)}))),A.registerEvent(A.app.workspace.on("active-leaf-change",(async e=>{var t;const i=A.activeExcalidrawView,n=e.view instanceof ExcalidrawView?e.view:null;if(A.activeExcalidrawView=n,n&&(A.lastActiveExcalidrawFilePath=null===(t=n.file)||void 0===t?void 0:t.path),i&&i!=n&&(i.leaf!=e&&i.semaphores.dirty&&await i.save(!0),i.file&&A.triggerEmbedUpdates(i.file.path)),n&&(!i||i.leaf!=e)){const A=n.file;n.file&&setTimeout((()=>{var e;n&&n._loaded&&(null===(e=n.file)||void 0===e?void 0:e.path)===(null==A?void 0:A.path)&&(n.activeLoader||n.loadSceneFiles())}),2e3)}if(A.popScope&&(A.popScope(),A.popScope=null),n){const e=this.app.keymap.getRootScope(),t=e.register(["Mod"],"Enter",(()=>!0));e.keys.unshift(e.keys.pop()),A.popScope=()=>e.unregister(t)}}))),A.addFileSaveTriggerEventHandlers();const e=A.app.metadataCache;e.getCachedFiles().forEach((t=>{var i;const n=null===(i=e.getCache(t))||void 0===i?void 0:i.frontmatter;(n&&void 0!==n[FRONTMATTER_KEY]||t.match(/\.excalidraw$/))&&A.updateFileCache(A.app.vault.getAbstractFileByPath(t),n)})),this.registerEvent(e.on("changed",((A,e,t)=>this.updateFileCache(A,null==t?void 0:t.frontmatter))))}))}addFileSaveTriggerEventHandlers(){this.registerEvent(this.app.workspace.on("click",(A=>{this.activeExcalidrawView&&this.activeExcalidrawView.semaphores.dirty&&(!A.target||"excalidraw__canvas"!==A.target.className&&!getParentOfClass(A.target,"excalidraw-wrapper"))&&this.activeExcalidrawView.save()}))),this.registerEvent(this.app.workspace.on("file-menu",(()=>{this.activeExcalidrawView&&this.activeExcalidrawView.semaphores.dirty&&this.activeExcalidrawView.save()}))),this.modalContainerObserver=new MutationObserver((async A=>{1===A.length&&"childList"===A[0].type&&1===A[0].addedNodes.length&&this.activeExcalidrawView&&this.activeExcalidrawView.semaphores.dirty&&this.activeExcalidrawView.save()})),this.modalContainerObserver.observe(document.body,{childList:!0});const A=document.querySelector(".workspace-drawer.mod-left"),e=document.querySelector(".workspace-drawer.mod-right");if(A||e){const t=async A=>{"display: none;"===A[0].oldValue&&this.activeExcalidrawView&&this.activeExcalidrawView.semaphores.dirty&&this.activeExcalidrawView.save()},i={attributeOldValue:!0,attributeFilter:["style"]};A&&(this.workspaceDrawerLeftObserver=new MutationObserver(t),this.workspaceDrawerLeftObserver.observe(A,i)),e&&(this.workspaceDrawerRightObserver=new MutationObserver(t),this.workspaceDrawerRightObserver.observe(e,i))}}updateFileCache(A,e,t=!1){e&&void 0!==e[FRONTMATTER_KEY]?this.excalidrawFiles.add(A):t||"excalidraw"!==A.extension?this.excalidrawFiles.delete(A):this.excalidrawFiles.add(A)}onunload(){destroyExcalidrawAutomate(),this.popScope&&(this.popScope(),this.popScope=null),this.observer.disconnect(),this.themeObserver.disconnect(),this.modalContainerObserver.disconnect(),this.workspaceDrawerLeftObserver&&this.workspaceDrawerLeftObserver.disconnect(),this.workspaceDrawerRightObserver&&this.workspaceDrawerRightObserver.disconnect(),this.fileExplorerObserver&&this.fileExplorerObserver.disconnect(),this.app.workspace.getLeavesOfType("excalidraw").forEach((A=>{this.setMarkdownView(A)})),this.mathjaxDiv&&document.body.removeChild(this.mathjaxDiv),Object.values(this.packageMap).forEach((A=>{delete A.excalidrawLib,delete A.reactDOM,delete A.react}))}async embedDrawing(A){const e=this.app.workspace.getActiveViewOfType(obsidian.MarkdownView);if(e&&e.file){const t=this.app.metadataCache.fileToLinktext(A,e.file.path,"excalidraw"===this.settings.embedType),i=e.editor;if("excalidraw"===this.settings.embedType)return i.replaceSelection(this.settings.embedWikiLink?`![[${t}]]`:`![](${encodeURI(t)})`),void i.focus();const n=getIMGPathFromExcalidrawFile(t,`.${this.settings.embedType.toLowerCase()}`),a=getIMGPathFromExcalidrawFile(A.path,`.${this.settings.embedType.toLowerCase()}`);this.app.vault.getAbstractFileByPath(a)||(await this.app.vault.create(a,""),await sleep$1(200)),i.replaceSelection(this.settings.embedWikiLink?`![[${n}]]\n%%[[${t}|🖋 Edit in Excalidraw]]%%`:`![](${encodeURI(n)})\n%%[🖋 Edit in Excalidraw](${encodeURI(t)})%%`),i.focus()}}async loadSettings(){this.settings=Object.assign({},DEFAULT_SETTINGS,await this.loadData()),setLeftHandedMode(this.settings.isLeftHanded),this.settings.autosave=!0,this.settings.autosaveInterval=1e4}async saveSettings(){await this.saveData(this.settings)}getStencilLibrary(){return""===this.settings.library||"deprecated"===this.settings.library?this.settings.library2:JSON_parse(this.settings.library)}setStencilLibrary(A){this.settings.library="deprecated",this.settings.library2=A}triggerEmbedUpdates(A){const e=new Set;app.workspace.iterateAllLeaves((t=>{const i=app.isMobile?document:t.view.containerEl.ownerDocument;if(!i)return;if(e.has(i))return;e.add(i);const n=i.createEvent("Event");n.initEvent(RERENDER_EVENT,!0,!1),i.querySelectorAll("div[class^='excalidraw-svg']"+(A?`[src='${A.replaceAll("'","\\'")}']`:"")).forEach((A=>A.dispatchEvent(n)))}))}openDrawing(A,e){let t;"popout-window"===e?t=app.workspace.openPopoutLeaf():(t=this.app.workspace.getLeaf(!1),"empty"!==t.view.getViewType()&&"new-pane"===e&&(t=getNewOrAdjacentLeaf(this,t))),t.setViewState({type:"excalidraw",state:{file:A.path}})}async getBlankDrawing(){const A=this.app.metadataCache.getFirstLinkpathDest(obsidian.normalizePath(this.settings.templateFilePath),"");if(A&&A instanceof obsidian.TFile&&("md"==A.extension&&!this.settings.compatibilityMode||"excalidraw"==A.extension&&this.settings.compatibilityMode)){const e=await this.app.vault.read(A);if(e)return this.settings.matchTheme?changeThemeOfExcalidrawMD(e):e}if(this.settings.compatibilityMode)return this.settings.matchTheme&&isObsidianThemeDark()?DARK_BLANK_DRAWING:BLANK_DRAWING;const e=this.settings.matchTheme&&isObsidianThemeDark()?DARK_BLANK_DRAWING:BLANK_DRAWING;return`${FRONTMATTER}\n${getMarkdownDrawingSection(e,this.settings.compress)}`}async exportSceneToMD(A){var e,t;if(!A)return"";const i=null===(e=JSON_parse(A).elements)||void 0===e?void 0:e.filter((A=>"text"==A.type));let n,a="# Text Elements\n";for(const e of i)n=e.id,e.id.length>8&&(n=nanoid(),A=A.replaceAll(e.id,n)),a+=`${null!==(t=e.originalText)&&void 0!==t?t:e.text} ^${n}\n\n`;return a+getMarkdownDrawingSection(JSON.stringify(JSON_parse(A),null,"\t"),this.settings.compress)}async createDrawing(A,e,t){const i=obsidian.normalizePath(e||this.settings.folder);await checkAndCreateFolder(this.app.vault,i);const n=getNewUniqueFilepath(this.app.vault,A,i),a=await this.app.vault.create(n,null!=t?t:await this.getBlankDrawing());let s=0;for(;a instanceof obsidian.TFile&&!this.isExcalidrawFile(a)&&s++<10;)await sleep$1(50);return s>10&&errorlog({file:a,error:"new drawing not recognized as an excalidraw file",fn:this.createDrawing}),a}async createAndOpenDrawing(A,e,t,i){const n=await this.createDrawing(A,t,i);return this.openDrawing(n,e),n.path}async setMarkdownView(A){const e=A.view.getState();await A.setViewState({type:"excalidraw",state:{file:null}}),await A.setViewState({type:"markdown",state:e,popstate:!0},{focus:!0})}async setExcalidrawView(A){await A.setViewState({type:"excalidraw",state:A.view.getState(),popstate:!0})}isExcalidrawFile(A){if("excalidraw"==A.extension)return!0;const e=A?this.app.metadataCache.getFileCache(A):null;return!!(null==e?void 0:e.frontmatter)&&!!e.frontmatter[FRONTMATTER_KEY]}async exportLibrary(){this.app.isMobile?new Prompt(this.app,"Please provide a filename","my-library","filename, leave blank to cancel action").openAndGetValue((async A=>{if(!A)return;A=`${A}.excalidrawlib`;const e=obsidian.normalizePath(this.settings.folder);await checkAndCreateFolder(this.app.vault,e);const t=getNewUniqueFilepath(this.app.vault,A,e);this.app.vault.create(t,this.settings.library),new obsidian.Notice(`Exported library to ${t}`,6e3)})):download("data:text/plain;charset=utf-8",encodeURIComponent(JSON.stringify(this.settings.library2,null,"\t")),"my-obsidian-library.excalidrawlib")}}module.exports=ExcalidrawPlugin; diff --git a/.obsidian/plugins/obsidian-excalidraw/manifest.json b/.obsidian/plugins/obsidian-excalidraw/manifest.json new file mode 100644 index 0000000..7b1ca4e --- /dev/null +++ b/.obsidian/plugins/obsidian-excalidraw/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "obsidian-excalidraw-plugin", + "name": "Excalidraw", + "version": "1.7.7", + "minAppVersion": "0.15.4", + "description": "An Obsidian plugin to edit and view Excalidraw drawings", + "author": "Zsolt Viczian", + "authorUrl": "https://zsolt.blog", + "isDesktopOnly": false +} diff --git a/.obsidian/plugins/obsidian-excalidraw/styles.css b/.obsidian/plugins/obsidian-excalidraw/styles.css new file mode 100644 index 0000000..a9283e6 --- /dev/null +++ b/.obsidian/plugins/obsidian-excalidraw/styles.css @@ -0,0 +1 @@ +.App{font-family:sans-serif;text-align:center}.excalidraw-wrapper{height:100%;margin:0px;background-color:#fff}.context-menu-option__shortcut{background-color:transparent!important}.block-language-excalidraw{text-align:center}.excalidraw .github-corner{display:none}img.excalidraw-svg-right-wrap{float:right;margin:0px 0px 20px 20px}img.excalidraw-svg-left-wrap{float:left;margin:0px 35px 20px 0px}img.excalidraw-svg-right{float:right}.excalidraw-svg-center{text-align:center}img.excalidraw-svg-left{float:left}div.excalidraw-svg-right,div.excalidraw-svg-left{display:table;width:100%}button.ToolIcon_type_button[title=Export]{display:none}.excalidraw-prompt-div{display:flex;max-width:800px}.excalidraw-prompt-form{display:flex;flex-grow:1}.excalidraw-prompt-input{flex-grow:1}li[data-testid]{border:0!important;margin:0!important;padding:0!important;width:100%!important}.excalidraw .context-menu-option-separator{margin:4px!important}.excalidraw .popover{padding:0!important;border-color:transparent!important;border:0!important;box-shadow:0!important;background-color:transparent!important}.disable-zen-mode--visible{color:var(--text-primary-color)}.disable-zen-mode{width:9em!important}.ex-coffee-div{text-align:center;margin-bottom:20px}.excalidraw-scriptengine-install td>img{width:100%;max-width:800px}.excalidraw-scriptengine-install img.coffee{width:130px}.excalidraw-scriptengine-install tr{vertical-align:top}.excalidraw-scriptengine-install table{max-width:130ch}.excalidraw-scriptengine-install td.label{min-width:11ch;font-weight:bold;padding-right:5px}.excalidraw-scriptengine-install td.data{width:100%}.modal-content.excalidraw-scriptengine-install{max-width:130ch;user-select:text}.excalidraw-scriptengine-install .modal{max-height:90%}.excalidraw-prompt-center{text-align:center}.excalidraw-prompt-center.filepath{text-align:center;font-weight:bold;margin-bottom:2em}.excalidraw-dirty{color:red}.workspace-leaf-content .excalidraw-view{padding:0px 1px}.excalidraw-videoWrapper{max-width:600px}.excalidraw-videoWrapper div{position:relative;padding-bottom:56.25%;height:0;margin:0 auto}.excalidraw-videoWrapper iframe{position:absolute;top:0;left:0;width:100%;height:100%}.excalidraw-release{padding-right:5px;margin-right:-5px;max-width:130ch;user-select:text}.excalidraw-release .modal{max-height:90%}.excalidraw .Island .scrollbar{--scrollbar-thumb-bg: silver}.excalidraw .ToolIcon__icon img{height:1em}.excalidraw-scriptengine-install tbody>tr>td>div>img{height:20px;background-color:silver;padding:2px}.excalidraw-scriptengine-install tbody>tr>td>div{width:50px;display:inline-block}.excalidraw-release p>a>img{width:100%} diff --git a/.obsidian/plugins/obsidian-git/data.json b/.obsidian/plugins/obsidian-git/data.json new file mode 100644 index 0000000..81d58f9 --- /dev/null +++ b/.obsidian/plugins/obsidian-git/data.json @@ -0,0 +1,55 @@ +{ + "commitMessage": "vault backup: {{date}}", + "commitDateFormat": "YYYY-MM-DD HH:mm:ss", + "autoSaveInterval": 60, + "autoPushInterval": 0, + "autoPullInterval": 30, + "autoPullOnBoot": true, + "disablePush": false, + "pullBeforePush": true, + "disablePopups": false, + "listChangedFilesInMessageBody": true, + "showStatusBar": true, + "updateSubmodules": false, + "syncMethod": "merge", + "customMessageOnAutoBackup": false, + "autoBackupAfterFileChange": true, + "treeStructure": false, + "refreshSourceControl": true, + "basePath": "", + "differentIntervalCommitAndPush": false, + "changedFilesInStatusBar": false, + "showedMobileNotice": true, + "refreshSourceControlTimer": 7000, + "showBranchStatusBar": true, + "setLastSaveToLastCommit": false, + "submoduleRecurseCheckout": false, + "gitDir": "", + "showFileMenu": true, + "lineAuthor": { + "show": false, + "followMovement": "inactive", + "authorDisplay": "initials", + "showCommitHash": false, + "dateTimeFormatOptions": "date", + "dateTimeFormatCustomString": "YYYY-MM-DD HH:mm", + "dateTimeTimezone": "viewer-local", + "coloringMaxAge": "1y", + "colorNew": { + "r": 255, + "g": 150, + "b": 150 + }, + "colorOld": { + "r": 120, + "g": 160, + "b": 255 + }, + "textColorCss": "var(--text-muted)", + "ignoreWhitespace": false, + "gutterSpacingFallbackLength": 5, + "lastShownAuthorDisplay": "initials", + "lastShownDateTimeFormatOptions": "date" + }, + "autoCommitMessage": "vault backup: {{date}}" +} \ No newline at end of file diff --git a/.obsidian/plugins/obsidian-git/main.js b/.obsidian/plugins/obsidian-git/main.js new file mode 100644 index 0000000..586d7f4 --- /dev/null +++ b/.obsidian/plugins/obsidian-git/main.js @@ -0,0 +1,44111 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ESBUILD +if you want to view the source visit the plugins github repository (https://github.com/denolehov/obsidian-git) +*/ + +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __defNormalProp = (obj, key2, value) => key2 in obj ? __defProp(obj, key2, { enumerable: true, configurable: true, writable: true, value }) : obj[key2] = value; +var __esm = (fn, res) => function __init() { + return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res; +}; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key2 of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key2) && key2 !== except) + __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); +var __publicField = (obj, key2, value) => { + __defNormalProp(obj, typeof key2 !== "symbol" ? key2 + "" : key2, value); + return value; +}; + +// node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js +var require_base64_js = __commonJS({ + "node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js"(exports2) { + "use strict"; + init_polyfill_buffer(); + exports2.byteLength = byteLength; + exports2.toByteArray = toByteArray; + exports2.fromByteArray = fromByteArray; + var lookup = []; + var revLookup = []; + var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array; + var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + for (i = 0, len = code.length; i < len; ++i) { + lookup[i] = code[i]; + revLookup[code.charCodeAt(i)] = i; + } + var i; + var len; + revLookup["-".charCodeAt(0)] = 62; + revLookup["_".charCodeAt(0)] = 63; + function getLens(b64) { + var len2 = b64.length; + if (len2 % 4 > 0) { + throw new Error("Invalid string. Length must be a multiple of 4"); + } + var validLen = b64.indexOf("="); + if (validLen === -1) + validLen = len2; + var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4; + return [validLen, placeHoldersLen]; + } + function byteLength(b64) { + var lens = getLens(b64); + var validLen = lens[0]; + var placeHoldersLen = lens[1]; + return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen; + } + function _byteLength(b64, validLen, placeHoldersLen) { + return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen; + } + function toByteArray(b64) { + var tmp; + var lens = getLens(b64); + var validLen = lens[0]; + var placeHoldersLen = lens[1]; + var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen)); + var curByte = 0; + var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen; + var i2; + for (i2 = 0; i2 < len2; i2 += 4) { + tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)]; + arr[curByte++] = tmp >> 16 & 255; + arr[curByte++] = tmp >> 8 & 255; + arr[curByte++] = tmp & 255; + } + if (placeHoldersLen === 2) { + tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4; + arr[curByte++] = tmp & 255; + } + if (placeHoldersLen === 1) { + tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2; + arr[curByte++] = tmp >> 8 & 255; + arr[curByte++] = tmp & 255; + } + return arr; + } + function tripletToBase64(num2) { + return lookup[num2 >> 18 & 63] + lookup[num2 >> 12 & 63] + lookup[num2 >> 6 & 63] + lookup[num2 & 63]; + } + function encodeChunk(uint8, start, end) { + var tmp; + var output = []; + for (var i2 = start; i2 < end; i2 += 3) { + tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255); + output.push(tripletToBase64(tmp)); + } + return output.join(""); + } + function fromByteArray(uint8) { + var tmp; + var len2 = uint8.length; + var extraBytes = len2 % 3; + var parts = []; + var maxChunkLength = 16383; + for (var i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength) { + parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength)); + } + if (extraBytes === 1) { + tmp = uint8[len2 - 1]; + parts.push( + lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==" + ); + } else if (extraBytes === 2) { + tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1]; + parts.push( + lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=" + ); + } + return parts.join(""); + } + } +}); + +// node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js +var require_ieee754 = __commonJS({ + "node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js"(exports2) { + init_polyfill_buffer(); + exports2.read = function(buffer2, offset, isLE, mLen, nBytes) { + var e, m; + var eLen = nBytes * 8 - mLen - 1; + var eMax = (1 << eLen) - 1; + var eBias = eMax >> 1; + var nBits = -7; + var i = isLE ? nBytes - 1 : 0; + var d = isLE ? -1 : 1; + var s = buffer2[offset + i]; + i += d; + e = s & (1 << -nBits) - 1; + s >>= -nBits; + nBits += eLen; + for (; nBits > 0; e = e * 256 + buffer2[offset + i], i += d, nBits -= 8) { + } + m = e & (1 << -nBits) - 1; + e >>= -nBits; + nBits += mLen; + for (; nBits > 0; m = m * 256 + buffer2[offset + i], i += d, nBits -= 8) { + } + if (e === 0) { + e = 1 - eBias; + } else if (e === eMax) { + return m ? NaN : (s ? -1 : 1) * Infinity; + } else { + m = m + Math.pow(2, mLen); + e = e - eBias; + } + return (s ? -1 : 1) * m * Math.pow(2, e - mLen); + }; + exports2.write = function(buffer2, value, offset, isLE, mLen, nBytes) { + var e, m, c; + var eLen = nBytes * 8 - mLen - 1; + var eMax = (1 << eLen) - 1; + var eBias = eMax >> 1; + var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0; + var i = isLE ? 0 : nBytes - 1; + var d = isLE ? 1 : -1; + var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0; + value = Math.abs(value); + if (isNaN(value) || value === Infinity) { + m = isNaN(value) ? 1 : 0; + e = eMax; + } else { + e = Math.floor(Math.log(value) / Math.LN2); + if (value * (c = Math.pow(2, -e)) < 1) { + e--; + c *= 2; + } + if (e + eBias >= 1) { + value += rt / c; + } else { + value += rt * Math.pow(2, 1 - eBias); + } + if (value * c >= 2) { + e++; + c /= 2; + } + if (e + eBias >= eMax) { + m = 0; + e = eMax; + } else if (e + eBias >= 1) { + m = (value * c - 1) * Math.pow(2, mLen); + e = e + eBias; + } else { + m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen); + e = 0; + } + } + for (; mLen >= 8; buffer2[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) { + } + e = e << mLen | m; + eLen += mLen; + for (; eLen > 0; buffer2[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) { + } + buffer2[offset + i - d] |= s * 128; + }; + } +}); + +// node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js +var require_buffer = __commonJS({ + "node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js"(exports2) { + "use strict"; + init_polyfill_buffer(); + var base64 = require_base64_js(); + var ieee754 = require_ieee754(); + var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null; + exports2.Buffer = Buffer2; + exports2.SlowBuffer = SlowBuffer; + exports2.INSPECT_MAX_BYTES = 50; + var K_MAX_LENGTH = 2147483647; + exports2.kMaxLength = K_MAX_LENGTH; + Buffer2.TYPED_ARRAY_SUPPORT = typedArraySupport(); + if (!Buffer2.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") { + console.error( + "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support." + ); + } + function typedArraySupport() { + try { + const arr = new Uint8Array(1); + const proto = { foo: function() { + return 42; + } }; + Object.setPrototypeOf(proto, Uint8Array.prototype); + Object.setPrototypeOf(arr, proto); + return arr.foo() === 42; + } catch (e) { + return false; + } + } + Object.defineProperty(Buffer2.prototype, "parent", { + enumerable: true, + get: function() { + if (!Buffer2.isBuffer(this)) + return void 0; + return this.buffer; + } + }); + Object.defineProperty(Buffer2.prototype, "offset", { + enumerable: true, + get: function() { + if (!Buffer2.isBuffer(this)) + return void 0; + return this.byteOffset; + } + }); + function createBuffer(length) { + if (length > K_MAX_LENGTH) { + throw new RangeError('The value "' + length + '" is invalid for option "size"'); + } + const buf = new Uint8Array(length); + Object.setPrototypeOf(buf, Buffer2.prototype); + return buf; + } + function Buffer2(arg, encodingOrOffset, length) { + if (typeof arg === "number") { + if (typeof encodingOrOffset === "string") { + throw new TypeError( + 'The "string" argument must be of type string. Received type number' + ); + } + return allocUnsafe(arg); + } + return from(arg, encodingOrOffset, length); + } + Buffer2.poolSize = 8192; + function from(value, encodingOrOffset, length) { + if (typeof value === "string") { + return fromString2(value, encodingOrOffset); + } + if (ArrayBuffer.isView(value)) { + return fromArrayView(value); + } + if (value == null) { + throw new TypeError( + "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value + ); + } + if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) { + return fromArrayBuffer(value, encodingOrOffset, length); + } + if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) { + return fromArrayBuffer(value, encodingOrOffset, length); + } + if (typeof value === "number") { + throw new TypeError( + 'The "value" argument must not be of type number. Received type number' + ); + } + const valueOf = value.valueOf && value.valueOf(); + if (valueOf != null && valueOf !== value) { + return Buffer2.from(valueOf, encodingOrOffset, length); + } + const b = fromObject(value); + if (b) + return b; + if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") { + return Buffer2.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length); + } + throw new TypeError( + "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value + ); + } + Buffer2.from = function(value, encodingOrOffset, length) { + return from(value, encodingOrOffset, length); + }; + Object.setPrototypeOf(Buffer2.prototype, Uint8Array.prototype); + Object.setPrototypeOf(Buffer2, Uint8Array); + function assertSize(size) { + if (typeof size !== "number") { + throw new TypeError('"size" argument must be of type number'); + } else if (size < 0) { + throw new RangeError('The value "' + size + '" is invalid for option "size"'); + } + } + function alloc(size, fill, encoding) { + assertSize(size); + if (size <= 0) { + return createBuffer(size); + } + if (fill !== void 0) { + return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill); + } + return createBuffer(size); + } + Buffer2.alloc = function(size, fill, encoding) { + return alloc(size, fill, encoding); + }; + function allocUnsafe(size) { + assertSize(size); + return createBuffer(size < 0 ? 0 : checked(size) | 0); + } + Buffer2.allocUnsafe = function(size) { + return allocUnsafe(size); + }; + Buffer2.allocUnsafeSlow = function(size) { + return allocUnsafe(size); + }; + function fromString2(string, encoding) { + if (typeof encoding !== "string" || encoding === "") { + encoding = "utf8"; + } + if (!Buffer2.isEncoding(encoding)) { + throw new TypeError("Unknown encoding: " + encoding); + } + const length = byteLength(string, encoding) | 0; + let buf = createBuffer(length); + const actual = buf.write(string, encoding); + if (actual !== length) { + buf = buf.slice(0, actual); + } + return buf; + } + function fromArrayLike(array) { + const length = array.length < 0 ? 0 : checked(array.length) | 0; + const buf = createBuffer(length); + for (let i = 0; i < length; i += 1) { + buf[i] = array[i] & 255; + } + return buf; + } + function fromArrayView(arrayView) { + if (isInstance(arrayView, Uint8Array)) { + const copy2 = new Uint8Array(arrayView); + return fromArrayBuffer(copy2.buffer, copy2.byteOffset, copy2.byteLength); + } + return fromArrayLike(arrayView); + } + function fromArrayBuffer(array, byteOffset, length) { + if (byteOffset < 0 || array.byteLength < byteOffset) { + throw new RangeError('"offset" is outside of buffer bounds'); + } + if (array.byteLength < byteOffset + (length || 0)) { + throw new RangeError('"length" is outside of buffer bounds'); + } + let buf; + if (byteOffset === void 0 && length === void 0) { + buf = new Uint8Array(array); + } else if (length === void 0) { + buf = new Uint8Array(array, byteOffset); + } else { + buf = new Uint8Array(array, byteOffset, length); + } + Object.setPrototypeOf(buf, Buffer2.prototype); + return buf; + } + function fromObject(obj) { + if (Buffer2.isBuffer(obj)) { + const len = checked(obj.length) | 0; + const buf = createBuffer(len); + if (buf.length === 0) { + return buf; + } + obj.copy(buf, 0, 0, len); + return buf; + } + if (obj.length !== void 0) { + if (typeof obj.length !== "number" || numberIsNaN(obj.length)) { + return createBuffer(0); + } + return fromArrayLike(obj); + } + if (obj.type === "Buffer" && Array.isArray(obj.data)) { + return fromArrayLike(obj.data); + } + } + function checked(length) { + if (length >= K_MAX_LENGTH) { + throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes"); + } + return length | 0; + } + function SlowBuffer(length) { + if (+length != length) { + length = 0; + } + return Buffer2.alloc(+length); + } + Buffer2.isBuffer = function isBuffer(b) { + return b != null && b._isBuffer === true && b !== Buffer2.prototype; + }; + Buffer2.compare = function compare(a, b) { + if (isInstance(a, Uint8Array)) + a = Buffer2.from(a, a.offset, a.byteLength); + if (isInstance(b, Uint8Array)) + b = Buffer2.from(b, b.offset, b.byteLength); + if (!Buffer2.isBuffer(a) || !Buffer2.isBuffer(b)) { + throw new TypeError( + 'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array' + ); + } + if (a === b) + return 0; + let x = a.length; + let y = b.length; + for (let i = 0, len = Math.min(x, y); i < len; ++i) { + if (a[i] !== b[i]) { + x = a[i]; + y = b[i]; + break; + } + } + if (x < y) + return -1; + if (y < x) + return 1; + return 0; + }; + Buffer2.isEncoding = function isEncoding(encoding) { + switch (String(encoding).toLowerCase()) { + case "hex": + case "utf8": + case "utf-8": + case "ascii": + case "latin1": + case "binary": + case "base64": + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return true; + default: + return false; + } + }; + Buffer2.concat = function concat(list, length) { + if (!Array.isArray(list)) { + throw new TypeError('"list" argument must be an Array of Buffers'); + } + if (list.length === 0) { + return Buffer2.alloc(0); + } + let i; + if (length === void 0) { + length = 0; + for (i = 0; i < list.length; ++i) { + length += list[i].length; + } + } + const buffer2 = Buffer2.allocUnsafe(length); + let pos = 0; + for (i = 0; i < list.length; ++i) { + let buf = list[i]; + if (isInstance(buf, Uint8Array)) { + if (pos + buf.length > buffer2.length) { + if (!Buffer2.isBuffer(buf)) + buf = Buffer2.from(buf); + buf.copy(buffer2, pos); + } else { + Uint8Array.prototype.set.call( + buffer2, + buf, + pos + ); + } + } else if (!Buffer2.isBuffer(buf)) { + throw new TypeError('"list" argument must be an Array of Buffers'); + } else { + buf.copy(buffer2, pos); + } + pos += buf.length; + } + return buffer2; + }; + function byteLength(string, encoding) { + if (Buffer2.isBuffer(string)) { + return string.length; + } + if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) { + return string.byteLength; + } + if (typeof string !== "string") { + throw new TypeError( + 'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string + ); + } + const len = string.length; + const mustMatch = arguments.length > 2 && arguments[2] === true; + if (!mustMatch && len === 0) + return 0; + let loweredCase = false; + for (; ; ) { + switch (encoding) { + case "ascii": + case "latin1": + case "binary": + return len; + case "utf8": + case "utf-8": + return utf8ToBytes(string).length; + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return len * 2; + case "hex": + return len >>> 1; + case "base64": + return base64ToBytes(string).length; + default: + if (loweredCase) { + return mustMatch ? -1 : utf8ToBytes(string).length; + } + encoding = ("" + encoding).toLowerCase(); + loweredCase = true; + } + } + } + Buffer2.byteLength = byteLength; + function slowToString(encoding, start, end) { + let loweredCase = false; + if (start === void 0 || start < 0) { + start = 0; + } + if (start > this.length) { + return ""; + } + if (end === void 0 || end > this.length) { + end = this.length; + } + if (end <= 0) { + return ""; + } + end >>>= 0; + start >>>= 0; + if (end <= start) { + return ""; + } + if (!encoding) + encoding = "utf8"; + while (true) { + switch (encoding) { + case "hex": + return hexSlice(this, start, end); + case "utf8": + case "utf-8": + return utf8Slice(this, start, end); + case "ascii": + return asciiSlice(this, start, end); + case "latin1": + case "binary": + return latin1Slice(this, start, end); + case "base64": + return base64Slice(this, start, end); + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return utf16leSlice(this, start, end); + default: + if (loweredCase) + throw new TypeError("Unknown encoding: " + encoding); + encoding = (encoding + "").toLowerCase(); + loweredCase = true; + } + } + } + Buffer2.prototype._isBuffer = true; + function swap(b, n, m) { + const i = b[n]; + b[n] = b[m]; + b[m] = i; + } + Buffer2.prototype.swap16 = function swap16() { + const len = this.length; + if (len % 2 !== 0) { + throw new RangeError("Buffer size must be a multiple of 16-bits"); + } + for (let i = 0; i < len; i += 2) { + swap(this, i, i + 1); + } + return this; + }; + Buffer2.prototype.swap32 = function swap32() { + const len = this.length; + if (len % 4 !== 0) { + throw new RangeError("Buffer size must be a multiple of 32-bits"); + } + for (let i = 0; i < len; i += 4) { + swap(this, i, i + 3); + swap(this, i + 1, i + 2); + } + return this; + }; + Buffer2.prototype.swap64 = function swap64() { + const len = this.length; + if (len % 8 !== 0) { + throw new RangeError("Buffer size must be a multiple of 64-bits"); + } + for (let i = 0; i < len; i += 8) { + swap(this, i, i + 7); + swap(this, i + 1, i + 6); + swap(this, i + 2, i + 5); + swap(this, i + 3, i + 4); + } + return this; + }; + Buffer2.prototype.toString = function toString() { + const length = this.length; + if (length === 0) + return ""; + if (arguments.length === 0) + return utf8Slice(this, 0, length); + return slowToString.apply(this, arguments); + }; + Buffer2.prototype.toLocaleString = Buffer2.prototype.toString; + Buffer2.prototype.equals = function equals2(b) { + if (!Buffer2.isBuffer(b)) + throw new TypeError("Argument must be a Buffer"); + if (this === b) + return true; + return Buffer2.compare(this, b) === 0; + }; + Buffer2.prototype.inspect = function inspect() { + let str = ""; + const max = exports2.INSPECT_MAX_BYTES; + str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim(); + if (this.length > max) + str += " ... "; + return ""; + }; + if (customInspectSymbol) { + Buffer2.prototype[customInspectSymbol] = Buffer2.prototype.inspect; + } + Buffer2.prototype.compare = function compare(target, start, end, thisStart, thisEnd) { + if (isInstance(target, Uint8Array)) { + target = Buffer2.from(target, target.offset, target.byteLength); + } + if (!Buffer2.isBuffer(target)) { + throw new TypeError( + 'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target + ); + } + if (start === void 0) { + start = 0; + } + if (end === void 0) { + end = target ? target.length : 0; + } + if (thisStart === void 0) { + thisStart = 0; + } + if (thisEnd === void 0) { + thisEnd = this.length; + } + if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { + throw new RangeError("out of range index"); + } + if (thisStart >= thisEnd && start >= end) { + return 0; + } + if (thisStart >= thisEnd) { + return -1; + } + if (start >= end) { + return 1; + } + start >>>= 0; + end >>>= 0; + thisStart >>>= 0; + thisEnd >>>= 0; + if (this === target) + return 0; + let x = thisEnd - thisStart; + let y = end - start; + const len = Math.min(x, y); + const thisCopy = this.slice(thisStart, thisEnd); + const targetCopy = target.slice(start, end); + for (let i = 0; i < len; ++i) { + if (thisCopy[i] !== targetCopy[i]) { + x = thisCopy[i]; + y = targetCopy[i]; + break; + } + } + if (x < y) + return -1; + if (y < x) + return 1; + return 0; + }; + function bidirectionalIndexOf(buffer2, val, byteOffset, encoding, dir) { + if (buffer2.length === 0) + return -1; + if (typeof byteOffset === "string") { + encoding = byteOffset; + byteOffset = 0; + } else if (byteOffset > 2147483647) { + byteOffset = 2147483647; + } else if (byteOffset < -2147483648) { + byteOffset = -2147483648; + } + byteOffset = +byteOffset; + if (numberIsNaN(byteOffset)) { + byteOffset = dir ? 0 : buffer2.length - 1; + } + if (byteOffset < 0) + byteOffset = buffer2.length + byteOffset; + if (byteOffset >= buffer2.length) { + if (dir) + return -1; + else + byteOffset = buffer2.length - 1; + } else if (byteOffset < 0) { + if (dir) + byteOffset = 0; + else + return -1; + } + if (typeof val === "string") { + val = Buffer2.from(val, encoding); + } + if (Buffer2.isBuffer(val)) { + if (val.length === 0) { + return -1; + } + return arrayIndexOf(buffer2, val, byteOffset, encoding, dir); + } else if (typeof val === "number") { + val = val & 255; + if (typeof Uint8Array.prototype.indexOf === "function") { + if (dir) { + return Uint8Array.prototype.indexOf.call(buffer2, val, byteOffset); + } else { + return Uint8Array.prototype.lastIndexOf.call(buffer2, val, byteOffset); + } + } + return arrayIndexOf(buffer2, [val], byteOffset, encoding, dir); + } + throw new TypeError("val must be string, number or Buffer"); + } + function arrayIndexOf(arr, val, byteOffset, encoding, dir) { + let indexSize = 1; + let arrLength = arr.length; + let valLength = val.length; + if (encoding !== void 0) { + encoding = String(encoding).toLowerCase(); + if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") { + if (arr.length < 2 || val.length < 2) { + return -1; + } + indexSize = 2; + arrLength /= 2; + valLength /= 2; + byteOffset /= 2; + } + } + function read(buf, i2) { + if (indexSize === 1) { + return buf[i2]; + } else { + return buf.readUInt16BE(i2 * indexSize); + } + } + let i; + if (dir) { + let foundIndex = -1; + for (i = byteOffset; i < arrLength; i++) { + if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { + if (foundIndex === -1) + foundIndex = i; + if (i - foundIndex + 1 === valLength) + return foundIndex * indexSize; + } else { + if (foundIndex !== -1) + i -= i - foundIndex; + foundIndex = -1; + } + } + } else { + if (byteOffset + valLength > arrLength) + byteOffset = arrLength - valLength; + for (i = byteOffset; i >= 0; i--) { + let found = true; + for (let j = 0; j < valLength; j++) { + if (read(arr, i + j) !== read(val, j)) { + found = false; + break; + } + } + if (found) + return i; + } + } + return -1; + } + Buffer2.prototype.includes = function includes(val, byteOffset, encoding) { + return this.indexOf(val, byteOffset, encoding) !== -1; + }; + Buffer2.prototype.indexOf = function indexOf(val, byteOffset, encoding) { + return bidirectionalIndexOf(this, val, byteOffset, encoding, true); + }; + Buffer2.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) { + return bidirectionalIndexOf(this, val, byteOffset, encoding, false); + }; + function hexWrite(buf, string, offset, length) { + offset = Number(offset) || 0; + const remaining = buf.length - offset; + if (!length) { + length = remaining; + } else { + length = Number(length); + if (length > remaining) { + length = remaining; + } + } + const strLen = string.length; + if (length > strLen / 2) { + length = strLen / 2; + } + let i; + for (i = 0; i < length; ++i) { + const parsed = parseInt(string.substr(i * 2, 2), 16); + if (numberIsNaN(parsed)) + return i; + buf[offset + i] = parsed; + } + return i; + } + function utf8Write(buf, string, offset, length) { + return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length); + } + function asciiWrite(buf, string, offset, length) { + return blitBuffer(asciiToBytes(string), buf, offset, length); + } + function base64Write(buf, string, offset, length) { + return blitBuffer(base64ToBytes(string), buf, offset, length); + } + function ucs2Write(buf, string, offset, length) { + return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length); + } + Buffer2.prototype.write = function write(string, offset, length, encoding) { + if (offset === void 0) { + encoding = "utf8"; + length = this.length; + offset = 0; + } else if (length === void 0 && typeof offset === "string") { + encoding = offset; + length = this.length; + offset = 0; + } else if (isFinite(offset)) { + offset = offset >>> 0; + if (isFinite(length)) { + length = length >>> 0; + if (encoding === void 0) + encoding = "utf8"; + } else { + encoding = length; + length = void 0; + } + } else { + throw new Error( + "Buffer.write(string, encoding, offset[, length]) is no longer supported" + ); + } + const remaining = this.length - offset; + if (length === void 0 || length > remaining) + length = remaining; + if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) { + throw new RangeError("Attempt to write outside buffer bounds"); + } + if (!encoding) + encoding = "utf8"; + let loweredCase = false; + for (; ; ) { + switch (encoding) { + case "hex": + return hexWrite(this, string, offset, length); + case "utf8": + case "utf-8": + return utf8Write(this, string, offset, length); + case "ascii": + case "latin1": + case "binary": + return asciiWrite(this, string, offset, length); + case "base64": + return base64Write(this, string, offset, length); + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return ucs2Write(this, string, offset, length); + default: + if (loweredCase) + throw new TypeError("Unknown encoding: " + encoding); + encoding = ("" + encoding).toLowerCase(); + loweredCase = true; + } + } + }; + Buffer2.prototype.toJSON = function toJSON() { + return { + type: "Buffer", + data: Array.prototype.slice.call(this._arr || this, 0) + }; + }; + function base64Slice(buf, start, end) { + if (start === 0 && end === buf.length) { + return base64.fromByteArray(buf); + } else { + return base64.fromByteArray(buf.slice(start, end)); + } + } + function utf8Slice(buf, start, end) { + end = Math.min(buf.length, end); + const res = []; + let i = start; + while (i < end) { + const firstByte = buf[i]; + let codePoint = null; + let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1; + if (i + bytesPerSequence <= end) { + let secondByte, thirdByte, fourthByte, tempCodePoint; + switch (bytesPerSequence) { + case 1: + if (firstByte < 128) { + codePoint = firstByte; + } + break; + case 2: + secondByte = buf[i + 1]; + if ((secondByte & 192) === 128) { + tempCodePoint = (firstByte & 31) << 6 | secondByte & 63; + if (tempCodePoint > 127) { + codePoint = tempCodePoint; + } + } + break; + case 3: + secondByte = buf[i + 1]; + thirdByte = buf[i + 2]; + if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) { + tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63; + if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) { + codePoint = tempCodePoint; + } + } + break; + case 4: + secondByte = buf[i + 1]; + thirdByte = buf[i + 2]; + fourthByte = buf[i + 3]; + if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) { + tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63; + if (tempCodePoint > 65535 && tempCodePoint < 1114112) { + codePoint = tempCodePoint; + } + } + } + } + if (codePoint === null) { + codePoint = 65533; + bytesPerSequence = 1; + } else if (codePoint > 65535) { + codePoint -= 65536; + res.push(codePoint >>> 10 & 1023 | 55296); + codePoint = 56320 | codePoint & 1023; + } + res.push(codePoint); + i += bytesPerSequence; + } + return decodeCodePointsArray(res); + } + var MAX_ARGUMENTS_LENGTH = 4096; + function decodeCodePointsArray(codePoints) { + const len = codePoints.length; + if (len <= MAX_ARGUMENTS_LENGTH) { + return String.fromCharCode.apply(String, codePoints); + } + let res = ""; + let i = 0; + while (i < len) { + res += String.fromCharCode.apply( + String, + codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) + ); + } + return res; + } + function asciiSlice(buf, start, end) { + let ret = ""; + end = Math.min(buf.length, end); + for (let i = start; i < end; ++i) { + ret += String.fromCharCode(buf[i] & 127); + } + return ret; + } + function latin1Slice(buf, start, end) { + let ret = ""; + end = Math.min(buf.length, end); + for (let i = start; i < end; ++i) { + ret += String.fromCharCode(buf[i]); + } + return ret; + } + function hexSlice(buf, start, end) { + const len = buf.length; + if (!start || start < 0) + start = 0; + if (!end || end < 0 || end > len) + end = len; + let out = ""; + for (let i = start; i < end; ++i) { + out += hexSliceLookupTable[buf[i]]; + } + return out; + } + function utf16leSlice(buf, start, end) { + const bytes = buf.slice(start, end); + let res = ""; + for (let i = 0; i < bytes.length - 1; i += 2) { + res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256); + } + return res; + } + Buffer2.prototype.slice = function slice(start, end) { + const len = this.length; + start = ~~start; + end = end === void 0 ? len : ~~end; + if (start < 0) { + start += len; + if (start < 0) + start = 0; + } else if (start > len) { + start = len; + } + if (end < 0) { + end += len; + if (end < 0) + end = 0; + } else if (end > len) { + end = len; + } + if (end < start) + end = start; + const newBuf = this.subarray(start, end); + Object.setPrototypeOf(newBuf, Buffer2.prototype); + return newBuf; + }; + function checkOffset(offset, ext, length) { + if (offset % 1 !== 0 || offset < 0) + throw new RangeError("offset is not uint"); + if (offset + ext > length) + throw new RangeError("Trying to access beyond buffer length"); + } + Buffer2.prototype.readUintLE = Buffer2.prototype.readUIntLE = function readUIntLE(offset, byteLength2, noAssert) { + offset = offset >>> 0; + byteLength2 = byteLength2 >>> 0; + if (!noAssert) + checkOffset(offset, byteLength2, this.length); + let val = this[offset]; + let mul = 1; + let i = 0; + while (++i < byteLength2 && (mul *= 256)) { + val += this[offset + i] * mul; + } + return val; + }; + Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) { + offset = offset >>> 0; + byteLength2 = byteLength2 >>> 0; + if (!noAssert) { + checkOffset(offset, byteLength2, this.length); + } + let val = this[offset + --byteLength2]; + let mul = 1; + while (byteLength2 > 0 && (mul *= 256)) { + val += this[offset + --byteLength2] * mul; + } + return val; + }; + Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 = function readUInt8(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 1, this.length); + return this[offset]; + }; + Buffer2.prototype.readUint16LE = Buffer2.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 2, this.length); + return this[offset] | this[offset + 1] << 8; + }; + Buffer2.prototype.readUint16BE = Buffer2.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 2, this.length); + return this[offset] << 8 | this[offset + 1]; + }; + Buffer2.prototype.readUint32LE = Buffer2.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 4, this.length); + return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216; + }; + Buffer2.prototype.readUint32BE = Buffer2.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 4, this.length); + return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]); + }; + Buffer2.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) { + offset = offset >>> 0; + validateNumber(offset, "offset"); + const first2 = this[offset]; + const last2 = this[offset + 7]; + if (first2 === void 0 || last2 === void 0) { + boundsError(offset, this.length - 8); + } + const lo = first2 + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24; + const hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last2 * 2 ** 24; + return BigInt(lo) + (BigInt(hi) << BigInt(32)); + }); + Buffer2.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) { + offset = offset >>> 0; + validateNumber(offset, "offset"); + const first2 = this[offset]; + const last2 = this[offset + 7]; + if (first2 === void 0 || last2 === void 0) { + boundsError(offset, this.length - 8); + } + const hi = first2 * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset]; + const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last2; + return (BigInt(hi) << BigInt(32)) + BigInt(lo); + }); + Buffer2.prototype.readIntLE = function readIntLE(offset, byteLength2, noAssert) { + offset = offset >>> 0; + byteLength2 = byteLength2 >>> 0; + if (!noAssert) + checkOffset(offset, byteLength2, this.length); + let val = this[offset]; + let mul = 1; + let i = 0; + while (++i < byteLength2 && (mul *= 256)) { + val += this[offset + i] * mul; + } + mul *= 128; + if (val >= mul) + val -= Math.pow(2, 8 * byteLength2); + return val; + }; + Buffer2.prototype.readIntBE = function readIntBE(offset, byteLength2, noAssert) { + offset = offset >>> 0; + byteLength2 = byteLength2 >>> 0; + if (!noAssert) + checkOffset(offset, byteLength2, this.length); + let i = byteLength2; + let mul = 1; + let val = this[offset + --i]; + while (i > 0 && (mul *= 256)) { + val += this[offset + --i] * mul; + } + mul *= 128; + if (val >= mul) + val -= Math.pow(2, 8 * byteLength2); + return val; + }; + Buffer2.prototype.readInt8 = function readInt8(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 1, this.length); + if (!(this[offset] & 128)) + return this[offset]; + return (255 - this[offset] + 1) * -1; + }; + Buffer2.prototype.readInt16LE = function readInt16LE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 2, this.length); + const val = this[offset] | this[offset + 1] << 8; + return val & 32768 ? val | 4294901760 : val; + }; + Buffer2.prototype.readInt16BE = function readInt16BE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 2, this.length); + const val = this[offset + 1] | this[offset] << 8; + return val & 32768 ? val | 4294901760 : val; + }; + Buffer2.prototype.readInt32LE = function readInt32LE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 4, this.length); + return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24; + }; + Buffer2.prototype.readInt32BE = function readInt32BE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 4, this.length); + return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]; + }; + Buffer2.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) { + offset = offset >>> 0; + validateNumber(offset, "offset"); + const first2 = this[offset]; + const last2 = this[offset + 7]; + if (first2 === void 0 || last2 === void 0) { + boundsError(offset, this.length - 8); + } + const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last2 << 24); + return (BigInt(val) << BigInt(32)) + BigInt(first2 + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24); + }); + Buffer2.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) { + offset = offset >>> 0; + validateNumber(offset, "offset"); + const first2 = this[offset]; + const last2 = this[offset + 7]; + if (first2 === void 0 || last2 === void 0) { + boundsError(offset, this.length - 8); + } + const val = (first2 << 24) + // Overflow + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset]; + return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last2); + }); + Buffer2.prototype.readFloatLE = function readFloatLE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 4, this.length); + return ieee754.read(this, offset, true, 23, 4); + }; + Buffer2.prototype.readFloatBE = function readFloatBE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 4, this.length); + return ieee754.read(this, offset, false, 23, 4); + }; + Buffer2.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 8, this.length); + return ieee754.read(this, offset, true, 52, 8); + }; + Buffer2.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 8, this.length); + return ieee754.read(this, offset, false, 52, 8); + }; + function checkInt(buf, value, offset, ext, max, min) { + if (!Buffer2.isBuffer(buf)) + throw new TypeError('"buffer" argument must be a Buffer instance'); + if (value > max || value < min) + throw new RangeError('"value" argument is out of bounds'); + if (offset + ext > buf.length) + throw new RangeError("Index out of range"); + } + Buffer2.prototype.writeUintLE = Buffer2.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength2, noAssert) { + value = +value; + offset = offset >>> 0; + byteLength2 = byteLength2 >>> 0; + if (!noAssert) { + const maxBytes = Math.pow(2, 8 * byteLength2) - 1; + checkInt(this, value, offset, byteLength2, maxBytes, 0); + } + let mul = 1; + let i = 0; + this[offset] = value & 255; + while (++i < byteLength2 && (mul *= 256)) { + this[offset + i] = value / mul & 255; + } + return offset + byteLength2; + }; + Buffer2.prototype.writeUintBE = Buffer2.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength2, noAssert) { + value = +value; + offset = offset >>> 0; + byteLength2 = byteLength2 >>> 0; + if (!noAssert) { + const maxBytes = Math.pow(2, 8 * byteLength2) - 1; + checkInt(this, value, offset, byteLength2, maxBytes, 0); + } + let i = byteLength2 - 1; + let mul = 1; + this[offset + i] = value & 255; + while (--i >= 0 && (mul *= 256)) { + this[offset + i] = value / mul & 255; + } + return offset + byteLength2; + }; + Buffer2.prototype.writeUint8 = Buffer2.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) + checkInt(this, value, offset, 1, 255, 0); + this[offset] = value & 255; + return offset + 1; + }; + Buffer2.prototype.writeUint16LE = Buffer2.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) + checkInt(this, value, offset, 2, 65535, 0); + this[offset] = value & 255; + this[offset + 1] = value >>> 8; + return offset + 2; + }; + Buffer2.prototype.writeUint16BE = Buffer2.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) + checkInt(this, value, offset, 2, 65535, 0); + this[offset] = value >>> 8; + this[offset + 1] = value & 255; + return offset + 2; + }; + Buffer2.prototype.writeUint32LE = Buffer2.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) + checkInt(this, value, offset, 4, 4294967295, 0); + this[offset + 3] = value >>> 24; + this[offset + 2] = value >>> 16; + this[offset + 1] = value >>> 8; + this[offset] = value & 255; + return offset + 4; + }; + Buffer2.prototype.writeUint32BE = Buffer2.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) + checkInt(this, value, offset, 4, 4294967295, 0); + this[offset] = value >>> 24; + this[offset + 1] = value >>> 16; + this[offset + 2] = value >>> 8; + this[offset + 3] = value & 255; + return offset + 4; + }; + function wrtBigUInt64LE(buf, value, offset, min, max) { + checkIntBI(value, min, max, buf, offset, 7); + let lo = Number(value & BigInt(4294967295)); + buf[offset++] = lo; + lo = lo >> 8; + buf[offset++] = lo; + lo = lo >> 8; + buf[offset++] = lo; + lo = lo >> 8; + buf[offset++] = lo; + let hi = Number(value >> BigInt(32) & BigInt(4294967295)); + buf[offset++] = hi; + hi = hi >> 8; + buf[offset++] = hi; + hi = hi >> 8; + buf[offset++] = hi; + hi = hi >> 8; + buf[offset++] = hi; + return offset; + } + function wrtBigUInt64BE(buf, value, offset, min, max) { + checkIntBI(value, min, max, buf, offset, 7); + let lo = Number(value & BigInt(4294967295)); + buf[offset + 7] = lo; + lo = lo >> 8; + buf[offset + 6] = lo; + lo = lo >> 8; + buf[offset + 5] = lo; + lo = lo >> 8; + buf[offset + 4] = lo; + let hi = Number(value >> BigInt(32) & BigInt(4294967295)); + buf[offset + 3] = hi; + hi = hi >> 8; + buf[offset + 2] = hi; + hi = hi >> 8; + buf[offset + 1] = hi; + hi = hi >> 8; + buf[offset] = hi; + return offset + 8; + } + Buffer2.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) { + return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff")); + }); + Buffer2.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) { + return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff")); + }); + Buffer2.prototype.writeIntLE = function writeIntLE(value, offset, byteLength2, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) { + const limit = Math.pow(2, 8 * byteLength2 - 1); + checkInt(this, value, offset, byteLength2, limit - 1, -limit); + } + let i = 0; + let mul = 1; + let sub = 0; + this[offset] = value & 255; + while (++i < byteLength2 && (mul *= 256)) { + if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { + sub = 1; + } + this[offset + i] = (value / mul >> 0) - sub & 255; + } + return offset + byteLength2; + }; + Buffer2.prototype.writeIntBE = function writeIntBE(value, offset, byteLength2, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) { + const limit = Math.pow(2, 8 * byteLength2 - 1); + checkInt(this, value, offset, byteLength2, limit - 1, -limit); + } + let i = byteLength2 - 1; + let mul = 1; + let sub = 0; + this[offset + i] = value & 255; + while (--i >= 0 && (mul *= 256)) { + if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { + sub = 1; + } + this[offset + i] = (value / mul >> 0) - sub & 255; + } + return offset + byteLength2; + }; + Buffer2.prototype.writeInt8 = function writeInt8(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) + checkInt(this, value, offset, 1, 127, -128); + if (value < 0) + value = 255 + value + 1; + this[offset] = value & 255; + return offset + 1; + }; + Buffer2.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) + checkInt(this, value, offset, 2, 32767, -32768); + this[offset] = value & 255; + this[offset + 1] = value >>> 8; + return offset + 2; + }; + Buffer2.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) + checkInt(this, value, offset, 2, 32767, -32768); + this[offset] = value >>> 8; + this[offset + 1] = value & 255; + return offset + 2; + }; + Buffer2.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) + checkInt(this, value, offset, 4, 2147483647, -2147483648); + this[offset] = value & 255; + this[offset + 1] = value >>> 8; + this[offset + 2] = value >>> 16; + this[offset + 3] = value >>> 24; + return offset + 4; + }; + Buffer2.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) + checkInt(this, value, offset, 4, 2147483647, -2147483648); + if (value < 0) + value = 4294967295 + value + 1; + this[offset] = value >>> 24; + this[offset + 1] = value >>> 16; + this[offset + 2] = value >>> 8; + this[offset + 3] = value & 255; + return offset + 4; + }; + Buffer2.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) { + return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff")); + }); + Buffer2.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) { + return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff")); + }); + function checkIEEE754(buf, value, offset, ext, max, min) { + if (offset + ext > buf.length) + throw new RangeError("Index out of range"); + if (offset < 0) + throw new RangeError("Index out of range"); + } + function writeFloat(buf, value, offset, littleEndian, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) { + checkIEEE754(buf, value, offset, 4, 34028234663852886e22, -34028234663852886e22); + } + ieee754.write(buf, value, offset, littleEndian, 23, 4); + return offset + 4; + } + Buffer2.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) { + return writeFloat(this, value, offset, true, noAssert); + }; + Buffer2.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) { + return writeFloat(this, value, offset, false, noAssert); + }; + function writeDouble(buf, value, offset, littleEndian, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) { + checkIEEE754(buf, value, offset, 8, 17976931348623157e292, -17976931348623157e292); + } + ieee754.write(buf, value, offset, littleEndian, 52, 8); + return offset + 8; + } + Buffer2.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) { + return writeDouble(this, value, offset, true, noAssert); + }; + Buffer2.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) { + return writeDouble(this, value, offset, false, noAssert); + }; + Buffer2.prototype.copy = function copy2(target, targetStart, start, end) { + if (!Buffer2.isBuffer(target)) + throw new TypeError("argument should be a Buffer"); + if (!start) + start = 0; + if (!end && end !== 0) + end = this.length; + if (targetStart >= target.length) + targetStart = target.length; + if (!targetStart) + targetStart = 0; + if (end > 0 && end < start) + end = start; + if (end === start) + return 0; + if (target.length === 0 || this.length === 0) + return 0; + if (targetStart < 0) { + throw new RangeError("targetStart out of bounds"); + } + if (start < 0 || start >= this.length) + throw new RangeError("Index out of range"); + if (end < 0) + throw new RangeError("sourceEnd out of bounds"); + if (end > this.length) + end = this.length; + if (target.length - targetStart < end - start) { + end = target.length - targetStart + start; + } + const len = end - start; + if (this === target && typeof Uint8Array.prototype.copyWithin === "function") { + this.copyWithin(targetStart, start, end); + } else { + Uint8Array.prototype.set.call( + target, + this.subarray(start, end), + targetStart + ); + } + return len; + }; + Buffer2.prototype.fill = function fill(val, start, end, encoding) { + if (typeof val === "string") { + if (typeof start === "string") { + encoding = start; + start = 0; + end = this.length; + } else if (typeof end === "string") { + encoding = end; + end = this.length; + } + if (encoding !== void 0 && typeof encoding !== "string") { + throw new TypeError("encoding must be a string"); + } + if (typeof encoding === "string" && !Buffer2.isEncoding(encoding)) { + throw new TypeError("Unknown encoding: " + encoding); + } + if (val.length === 1) { + const code = val.charCodeAt(0); + if (encoding === "utf8" && code < 128 || encoding === "latin1") { + val = code; + } + } + } else if (typeof val === "number") { + val = val & 255; + } else if (typeof val === "boolean") { + val = Number(val); + } + if (start < 0 || this.length < start || this.length < end) { + throw new RangeError("Out of range index"); + } + if (end <= start) { + return this; + } + start = start >>> 0; + end = end === void 0 ? this.length : end >>> 0; + if (!val) + val = 0; + let i; + if (typeof val === "number") { + for (i = start; i < end; ++i) { + this[i] = val; + } + } else { + const bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding); + const len = bytes.length; + if (len === 0) { + throw new TypeError('The value "' + val + '" is invalid for argument "value"'); + } + for (i = 0; i < end - start; ++i) { + this[i + start] = bytes[i % len]; + } + } + return this; + }; + var errors = {}; + function E(sym, getMessage, Base) { + errors[sym] = class NodeError extends Base { + constructor() { + super(); + Object.defineProperty(this, "message", { + value: getMessage.apply(this, arguments), + writable: true, + configurable: true + }); + this.name = `${this.name} [${sym}]`; + this.stack; + delete this.name; + } + get code() { + return sym; + } + set code(value) { + Object.defineProperty(this, "code", { + configurable: true, + enumerable: true, + value, + writable: true + }); + } + toString() { + return `${this.name} [${sym}]: ${this.message}`; + } + }; + } + E( + "ERR_BUFFER_OUT_OF_BOUNDS", + function(name) { + if (name) { + return `${name} is outside of buffer bounds`; + } + return "Attempt to access memory outside buffer bounds"; + }, + RangeError + ); + E( + "ERR_INVALID_ARG_TYPE", + function(name, actual) { + return `The "${name}" argument must be of type number. Received type ${typeof actual}`; + }, + TypeError + ); + E( + "ERR_OUT_OF_RANGE", + function(str, range, input) { + let msg = `The value of "${str}" is out of range.`; + let received = input; + if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) { + received = addNumericalSeparator(String(input)); + } else if (typeof input === "bigint") { + received = String(input); + if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) { + received = addNumericalSeparator(received); + } + received += "n"; + } + msg += ` It must be ${range}. Received ${received}`; + return msg; + }, + RangeError + ); + function addNumericalSeparator(val) { + let res = ""; + let i = val.length; + const start = val[0] === "-" ? 1 : 0; + for (; i >= start + 4; i -= 3) { + res = `_${val.slice(i - 3, i)}${res}`; + } + return `${val.slice(0, i)}${res}`; + } + function checkBounds(buf, offset, byteLength2) { + validateNumber(offset, "offset"); + if (buf[offset] === void 0 || buf[offset + byteLength2] === void 0) { + boundsError(offset, buf.length - (byteLength2 + 1)); + } + } + function checkIntBI(value, min, max, buf, offset, byteLength2) { + if (value > max || value < min) { + const n = typeof min === "bigint" ? "n" : ""; + let range; + if (byteLength2 > 3) { + if (min === 0 || min === BigInt(0)) { + range = `>= 0${n} and < 2${n} ** ${(byteLength2 + 1) * 8}${n}`; + } else { + range = `>= -(2${n} ** ${(byteLength2 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength2 + 1) * 8 - 1}${n}`; + } + } else { + range = `>= ${min}${n} and <= ${max}${n}`; + } + throw new errors.ERR_OUT_OF_RANGE("value", range, value); + } + checkBounds(buf, offset, byteLength2); + } + function validateNumber(value, name) { + if (typeof value !== "number") { + throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value); + } + } + function boundsError(value, length, type) { + if (Math.floor(value) !== value) { + validateNumber(value, type); + throw new errors.ERR_OUT_OF_RANGE(type || "offset", "an integer", value); + } + if (length < 0) { + throw new errors.ERR_BUFFER_OUT_OF_BOUNDS(); + } + throw new errors.ERR_OUT_OF_RANGE( + type || "offset", + `>= ${type ? 1 : 0} and <= ${length}`, + value + ); + } + var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g; + function base64clean(str) { + str = str.split("=")[0]; + str = str.trim().replace(INVALID_BASE64_RE, ""); + if (str.length < 2) + return ""; + while (str.length % 4 !== 0) { + str = str + "="; + } + return str; + } + function utf8ToBytes(string, units) { + units = units || Infinity; + let codePoint; + const length = string.length; + let leadSurrogate = null; + const bytes = []; + for (let i = 0; i < length; ++i) { + codePoint = string.charCodeAt(i); + if (codePoint > 55295 && codePoint < 57344) { + if (!leadSurrogate) { + if (codePoint > 56319) { + if ((units -= 3) > -1) + bytes.push(239, 191, 189); + continue; + } else if (i + 1 === length) { + if ((units -= 3) > -1) + bytes.push(239, 191, 189); + continue; + } + leadSurrogate = codePoint; + continue; + } + if (codePoint < 56320) { + if ((units -= 3) > -1) + bytes.push(239, 191, 189); + leadSurrogate = codePoint; + continue; + } + codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536; + } else if (leadSurrogate) { + if ((units -= 3) > -1) + bytes.push(239, 191, 189); + } + leadSurrogate = null; + if (codePoint < 128) { + if ((units -= 1) < 0) + break; + bytes.push(codePoint); + } else if (codePoint < 2048) { + if ((units -= 2) < 0) + break; + bytes.push( + codePoint >> 6 | 192, + codePoint & 63 | 128 + ); + } else if (codePoint < 65536) { + if ((units -= 3) < 0) + break; + bytes.push( + codePoint >> 12 | 224, + codePoint >> 6 & 63 | 128, + codePoint & 63 | 128 + ); + } else if (codePoint < 1114112) { + if ((units -= 4) < 0) + break; + bytes.push( + codePoint >> 18 | 240, + codePoint >> 12 & 63 | 128, + codePoint >> 6 & 63 | 128, + codePoint & 63 | 128 + ); + } else { + throw new Error("Invalid code point"); + } + } + return bytes; + } + function asciiToBytes(str) { + const byteArray = []; + for (let i = 0; i < str.length; ++i) { + byteArray.push(str.charCodeAt(i) & 255); + } + return byteArray; + } + function utf16leToBytes(str, units) { + let c, hi, lo; + const byteArray = []; + for (let i = 0; i < str.length; ++i) { + if ((units -= 2) < 0) + break; + c = str.charCodeAt(i); + hi = c >> 8; + lo = c % 256; + byteArray.push(lo); + byteArray.push(hi); + } + return byteArray; + } + function base64ToBytes(str) { + return base64.toByteArray(base64clean(str)); + } + function blitBuffer(src, dst, offset, length) { + let i; + for (i = 0; i < length; ++i) { + if (i + offset >= dst.length || i >= src.length) + break; + dst[i + offset] = src[i]; + } + return i; + } + function isInstance(obj, type) { + return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name; + } + function numberIsNaN(obj) { + return obj !== obj; + } + var hexSliceLookupTable = function() { + const alphabet = "0123456789abcdef"; + const table = new Array(256); + for (let i = 0; i < 16; ++i) { + const i16 = i * 16; + for (let j = 0; j < 16; ++j) { + table[i16 + j] = alphabet[i] + alphabet[j]; + } + } + return table; + }(); + function defineBigIntMethod(fn) { + return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn; + } + function BufferBigIntNotDefined() { + throw new Error("BigInt not supported"); + } + } +}); + +// polyfill_buffer.js +var import_obsidian, buffer, Buffer; +var init_polyfill_buffer = __esm({ + "polyfill_buffer.js"() { + import_obsidian = require("obsidian"); + if (import_obsidian.Platform.isMobileApp) { + buffer = require_buffer().Buffer; + } else { + buffer = global.Buffer; + } + Buffer = buffer; + } +}); + +// node_modules/.pnpm/async-lock@1.4.0/node_modules/async-lock/lib/index.js +var require_lib = __commonJS({ + "node_modules/.pnpm/async-lock@1.4.0/node_modules/async-lock/lib/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var AsyncLock2 = function(opts) { + opts = opts || {}; + this.Promise = opts.Promise || Promise; + this.queues = /* @__PURE__ */ Object.create(null); + this.domainReentrant = opts.domainReentrant || false; + if (this.domainReentrant) { + if (typeof process === "undefined" || typeof process.domain === "undefined") { + throw new Error( + "Domain-reentrant locks require `process.domain` to exist. Please flip `opts.domainReentrant = false`, use a NodeJS version that still implements Domain, or install a browser polyfill." + ); + } + this.domains = /* @__PURE__ */ Object.create(null); + } + this.timeout = opts.timeout || AsyncLock2.DEFAULT_TIMEOUT; + this.maxOccupationTime = opts.maxOccupationTime || AsyncLock2.DEFAULT_MAX_OCCUPATION_TIME; + this.maxExecutionTime = opts.maxExecutionTime || AsyncLock2.DEFAULT_MAX_EXECUTION_TIME; + if (opts.maxPending === Infinity || Number.isInteger(opts.maxPending) && opts.maxPending >= 0) { + this.maxPending = opts.maxPending; + } else { + this.maxPending = AsyncLock2.DEFAULT_MAX_PENDING; + } + }; + AsyncLock2.DEFAULT_TIMEOUT = 0; + AsyncLock2.DEFAULT_MAX_OCCUPATION_TIME = 0; + AsyncLock2.DEFAULT_MAX_EXECUTION_TIME = 0; + AsyncLock2.DEFAULT_MAX_PENDING = 1e3; + AsyncLock2.prototype.acquire = function(key2, fn, cb, opts) { + if (Array.isArray(key2)) { + return this._acquireBatch(key2, fn, cb, opts); + } + if (typeof fn !== "function") { + throw new Error("You must pass a function to execute"); + } + var deferredResolve = null; + var deferredReject = null; + var deferred2 = null; + if (typeof cb !== "function") { + opts = cb; + cb = null; + deferred2 = new this.Promise(function(resolve, reject) { + deferredResolve = resolve; + deferredReject = reject; + }); + } + opts = opts || {}; + var resolved = false; + var timer = null; + var occupationTimer = null; + var executionTimer = null; + var self2 = this; + var done = function(locked, err, ret) { + if (occupationTimer) { + clearTimeout(occupationTimer); + occupationTimer = null; + } + if (executionTimer) { + clearTimeout(executionTimer); + executionTimer = null; + } + if (locked) { + if (!!self2.queues[key2] && self2.queues[key2].length === 0) { + delete self2.queues[key2]; + } + if (self2.domainReentrant) { + delete self2.domains[key2]; + } + } + if (!resolved) { + if (!deferred2) { + if (typeof cb === "function") { + cb(err, ret); + } + } else { + if (err) { + deferredReject(err); + } else { + deferredResolve(ret); + } + } + resolved = true; + } + if (locked) { + if (!!self2.queues[key2] && self2.queues[key2].length > 0) { + self2.queues[key2].shift()(); + } + } + }; + var exec = function(locked) { + if (resolved) { + return done(locked); + } + if (timer) { + clearTimeout(timer); + timer = null; + } + if (self2.domainReentrant && locked) { + self2.domains[key2] = process.domain; + } + var maxExecutionTime = opts.maxExecutionTime || self2.maxExecutionTime; + if (maxExecutionTime) { + executionTimer = setTimeout(function() { + if (!!self2.queues[key2]) { + done(locked, new Error("Maximum execution time is exceeded " + key2)); + } + }, maxExecutionTime); + } + if (fn.length === 1) { + var called = false; + try { + fn(function(err, ret) { + if (!called) { + called = true; + done(locked, err, ret); + } + }); + } catch (err) { + if (!called) { + called = true; + done(locked, err); + } + } + } else { + self2._promiseTry(function() { + return fn(); + }).then(function(ret) { + done(locked, void 0, ret); + }, function(error) { + done(locked, error); + }); + } + }; + if (self2.domainReentrant && !!process.domain) { + exec = process.domain.bind(exec); + } + if (!self2.queues[key2]) { + self2.queues[key2] = []; + exec(true); + } else if (self2.domainReentrant && !!process.domain && process.domain === self2.domains[key2]) { + exec(false); + } else if (self2.queues[key2].length >= self2.maxPending) { + done(false, new Error("Too many pending tasks in queue " + key2)); + } else { + var taskFn = function() { + exec(true); + }; + if (opts.skipQueue) { + self2.queues[key2].unshift(taskFn); + } else { + self2.queues[key2].push(taskFn); + } + var timeout = opts.timeout || self2.timeout; + if (timeout) { + timer = setTimeout(function() { + timer = null; + done(false, new Error("async-lock timed out in queue " + key2)); + }, timeout); + } + } + var maxOccupationTime = opts.maxOccupationTime || self2.maxOccupationTime; + if (maxOccupationTime) { + occupationTimer = setTimeout(function() { + if (!!self2.queues[key2]) { + done(false, new Error("Maximum occupation time is exceeded in queue " + key2)); + } + }, maxOccupationTime); + } + if (deferred2) { + return deferred2; + } + }; + AsyncLock2.prototype._acquireBatch = function(keys, fn, cb, opts) { + if (typeof cb !== "function") { + opts = cb; + cb = null; + } + var self2 = this; + var getFn = function(key2, fn2) { + return function(cb2) { + self2.acquire(key2, fn2, cb2, opts); + }; + }; + var fnx = keys.reduceRight(function(prev, key2) { + return getFn(key2, prev); + }, fn); + if (typeof cb === "function") { + fnx(cb); + } else { + return new this.Promise(function(resolve, reject) { + if (fnx.length === 1) { + fnx(function(err, ret) { + if (err) { + reject(err); + } else { + resolve(ret); + } + }); + } else { + resolve(fnx()); + } + }); + } + }; + AsyncLock2.prototype.isBusy = function(key2) { + if (!key2) { + return Object.keys(this.queues).length > 0; + } else { + return !!this.queues[key2]; + } + }; + AsyncLock2.prototype._promiseTry = function(fn) { + try { + return this.Promise.resolve(fn()); + } catch (e) { + return this.Promise.reject(e); + } + }; + module2.exports = AsyncLock2; + } +}); + +// node_modules/.pnpm/async-lock@1.4.0/node_modules/async-lock/index.js +var require_async_lock = __commonJS({ + "node_modules/.pnpm/async-lock@1.4.0/node_modules/async-lock/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + module2.exports = require_lib(); + } +}); + +// node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js +var require_inherits_browser = __commonJS({ + "node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js"(exports2, module2) { + init_polyfill_buffer(); + if (typeof Object.create === "function") { + module2.exports = function inherits(ctor, superCtor) { + if (superCtor) { + ctor.super_ = superCtor; + ctor.prototype = Object.create(superCtor.prototype, { + constructor: { + value: ctor, + enumerable: false, + writable: true, + configurable: true + } + }); + } + }; + } else { + module2.exports = function inherits(ctor, superCtor) { + if (superCtor) { + ctor.super_ = superCtor; + var TempCtor = function() { + }; + TempCtor.prototype = superCtor.prototype; + ctor.prototype = new TempCtor(); + ctor.prototype.constructor = ctor; + } + }; + } + } +}); + +// node_modules/.pnpm/safe-buffer@5.2.1/node_modules/safe-buffer/index.js +var require_safe_buffer = __commonJS({ + "node_modules/.pnpm/safe-buffer@5.2.1/node_modules/safe-buffer/index.js"(exports2, module2) { + init_polyfill_buffer(); + var buffer2 = require_buffer(); + var Buffer2 = buffer2.Buffer; + function copyProps(src, dst) { + for (var key2 in src) { + dst[key2] = src[key2]; + } + } + if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) { + module2.exports = buffer2; + } else { + copyProps(buffer2, exports2); + exports2.Buffer = SafeBuffer; + } + function SafeBuffer(arg, encodingOrOffset, length) { + return Buffer2(arg, encodingOrOffset, length); + } + SafeBuffer.prototype = Object.create(Buffer2.prototype); + copyProps(Buffer2, SafeBuffer); + SafeBuffer.from = function(arg, encodingOrOffset, length) { + if (typeof arg === "number") { + throw new TypeError("Argument must not be a number"); + } + return Buffer2(arg, encodingOrOffset, length); + }; + SafeBuffer.alloc = function(size, fill, encoding) { + if (typeof size !== "number") { + throw new TypeError("Argument must be a number"); + } + var buf = Buffer2(size); + if (fill !== void 0) { + if (typeof encoding === "string") { + buf.fill(fill, encoding); + } else { + buf.fill(fill); + } + } else { + buf.fill(0); + } + return buf; + }; + SafeBuffer.allocUnsafe = function(size) { + if (typeof size !== "number") { + throw new TypeError("Argument must be a number"); + } + return Buffer2(size); + }; + SafeBuffer.allocUnsafeSlow = function(size) { + if (typeof size !== "number") { + throw new TypeError("Argument must be a number"); + } + return buffer2.SlowBuffer(size); + }; + } +}); + +// node_modules/.pnpm/sha.js@2.4.11/node_modules/sha.js/hash.js +var require_hash = __commonJS({ + "node_modules/.pnpm/sha.js@2.4.11/node_modules/sha.js/hash.js"(exports2, module2) { + init_polyfill_buffer(); + var Buffer2 = require_safe_buffer().Buffer; + function Hash2(blockSize, finalSize) { + this._block = Buffer2.alloc(blockSize); + this._finalSize = finalSize; + this._blockSize = blockSize; + this._len = 0; + } + Hash2.prototype.update = function(data, enc) { + if (typeof data === "string") { + enc = enc || "utf8"; + data = Buffer2.from(data, enc); + } + var block = this._block; + var blockSize = this._blockSize; + var length = data.length; + var accum = this._len; + for (var offset = 0; offset < length; ) { + var assigned = accum % blockSize; + var remainder = Math.min(length - offset, blockSize - assigned); + for (var i = 0; i < remainder; i++) { + block[assigned + i] = data[offset + i]; + } + accum += remainder; + offset += remainder; + if (accum % blockSize === 0) { + this._update(block); + } + } + this._len += length; + return this; + }; + Hash2.prototype.digest = function(enc) { + var rem = this._len % this._blockSize; + this._block[rem] = 128; + this._block.fill(0, rem + 1); + if (rem >= this._finalSize) { + this._update(this._block); + this._block.fill(0); + } + var bits = this._len * 8; + if (bits <= 4294967295) { + this._block.writeUInt32BE(bits, this._blockSize - 4); + } else { + var lowBits = (bits & 4294967295) >>> 0; + var highBits = (bits - lowBits) / 4294967296; + this._block.writeUInt32BE(highBits, this._blockSize - 8); + this._block.writeUInt32BE(lowBits, this._blockSize - 4); + } + this._update(this._block); + var hash2 = this._hash(); + return enc ? hash2.toString(enc) : hash2; + }; + Hash2.prototype._update = function() { + throw new Error("_update must be implemented by subclass"); + }; + module2.exports = Hash2; + } +}); + +// node_modules/.pnpm/sha.js@2.4.11/node_modules/sha.js/sha1.js +var require_sha1 = __commonJS({ + "node_modules/.pnpm/sha.js@2.4.11/node_modules/sha.js/sha1.js"(exports2, module2) { + init_polyfill_buffer(); + var inherits = require_inherits_browser(); + var Hash2 = require_hash(); + var Buffer2 = require_safe_buffer().Buffer; + var K2 = [ + 1518500249, + 1859775393, + 2400959708 | 0, + 3395469782 | 0 + ]; + var W = new Array(80); + function Sha1() { + this.init(); + this._w = W; + Hash2.call(this, 64, 56); + } + inherits(Sha1, Hash2); + Sha1.prototype.init = function() { + this._a = 1732584193; + this._b = 4023233417; + this._c = 2562383102; + this._d = 271733878; + this._e = 3285377520; + return this; + }; + function rotl1(num2) { + return num2 << 1 | num2 >>> 31; + } + function rotl5(num2) { + return num2 << 5 | num2 >>> 27; + } + function rotl30(num2) { + return num2 << 30 | num2 >>> 2; + } + function ft(s, b, c, d) { + if (s === 0) + return b & c | ~b & d; + if (s === 2) + return b & c | b & d | c & d; + return b ^ c ^ d; + } + Sha1.prototype._update = function(M) { + var W2 = this._w; + var a = this._a | 0; + var b = this._b | 0; + var c = this._c | 0; + var d = this._d | 0; + var e = this._e | 0; + for (var i = 0; i < 16; ++i) + W2[i] = M.readInt32BE(i * 4); + for (; i < 80; ++i) + W2[i] = rotl1(W2[i - 3] ^ W2[i - 8] ^ W2[i - 14] ^ W2[i - 16]); + for (var j = 0; j < 80; ++j) { + var s = ~~(j / 20); + var t = rotl5(a) + ft(s, b, c, d) + e + W2[j] + K2[s] | 0; + e = d; + d = c; + c = rotl30(b); + b = a; + a = t; + } + this._a = a + this._a | 0; + this._b = b + this._b | 0; + this._c = c + this._c | 0; + this._d = d + this._d | 0; + this._e = e + this._e | 0; + }; + Sha1.prototype._hash = function() { + var H = Buffer2.allocUnsafe(20); + H.writeInt32BE(this._a | 0, 0); + H.writeInt32BE(this._b | 0, 4); + H.writeInt32BE(this._c | 0, 8); + H.writeInt32BE(this._d | 0, 12); + H.writeInt32BE(this._e | 0, 16); + return H; + }; + module2.exports = Sha1; + } +}); + +// node_modules/.pnpm/crc-32@1.2.2/node_modules/crc-32/crc32.js +var require_crc32 = __commonJS({ + "node_modules/.pnpm/crc-32@1.2.2/node_modules/crc-32/crc32.js"(exports2) { + init_polyfill_buffer(); + var CRC32; + (function(factory) { + if (typeof DO_NOT_EXPORT_CRC === "undefined") { + if ("object" === typeof exports2) { + factory(exports2); + } else if ("function" === typeof define && define.amd) { + define(function() { + var module3 = {}; + factory(module3); + return module3; + }); + } else { + factory(CRC32 = {}); + } + } else { + factory(CRC32 = {}); + } + })(function(CRC322) { + CRC322.version = "1.2.2"; + function signed_crc_table() { + var c = 0, table = new Array(256); + for (var n = 0; n != 256; ++n) { + c = n; + c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1; + c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1; + c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1; + c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1; + c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1; + c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1; + c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1; + c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1; + table[n] = c; + } + return typeof Int32Array !== "undefined" ? new Int32Array(table) : table; + } + var T0 = signed_crc_table(); + function slice_by_16_tables(T) { + var c = 0, v = 0, n = 0, table = typeof Int32Array !== "undefined" ? new Int32Array(4096) : new Array(4096); + for (n = 0; n != 256; ++n) + table[n] = T[n]; + for (n = 0; n != 256; ++n) { + v = T[n]; + for (c = 256 + n; c < 4096; c += 256) + v = table[c] = v >>> 8 ^ T[v & 255]; + } + var out = []; + for (n = 1; n != 16; ++n) + out[n - 1] = typeof Int32Array !== "undefined" ? table.subarray(n * 256, n * 256 + 256) : table.slice(n * 256, n * 256 + 256); + return out; + } + var TT = slice_by_16_tables(T0); + var T1 = TT[0], T2 = TT[1], T3 = TT[2], T4 = TT[3], T5 = TT[4]; + var T6 = TT[5], T7 = TT[6], T8 = TT[7], T9 = TT[8], Ta = TT[9]; + var Tb = TT[10], Tc = TT[11], Td = TT[12], Te = TT[13], Tf = TT[14]; + function crc32_bstr(bstr, seed) { + var C = seed ^ -1; + for (var i = 0, L = bstr.length; i < L; ) + C = C >>> 8 ^ T0[(C ^ bstr.charCodeAt(i++)) & 255]; + return ~C; + } + function crc32_buf(B, seed) { + var C = seed ^ -1, L = B.length - 15, i = 0; + for (; i < L; ) + C = Tf[B[i++] ^ C & 255] ^ Te[B[i++] ^ C >> 8 & 255] ^ Td[B[i++] ^ C >> 16 & 255] ^ Tc[B[i++] ^ C >>> 24] ^ Tb[B[i++]] ^ Ta[B[i++]] ^ T9[B[i++]] ^ T8[B[i++]] ^ T7[B[i++]] ^ T6[B[i++]] ^ T5[B[i++]] ^ T4[B[i++]] ^ T3[B[i++]] ^ T2[B[i++]] ^ T1[B[i++]] ^ T0[B[i++]]; + L += 15; + while (i < L) + C = C >>> 8 ^ T0[(C ^ B[i++]) & 255]; + return ~C; + } + function crc32_str(str, seed) { + var C = seed ^ -1; + for (var i = 0, L = str.length, c = 0, d = 0; i < L; ) { + c = str.charCodeAt(i++); + if (c < 128) { + C = C >>> 8 ^ T0[(C ^ c) & 255]; + } else if (c < 2048) { + C = C >>> 8 ^ T0[(C ^ (192 | c >> 6 & 31)) & 255]; + C = C >>> 8 ^ T0[(C ^ (128 | c & 63)) & 255]; + } else if (c >= 55296 && c < 57344) { + c = (c & 1023) + 64; + d = str.charCodeAt(i++) & 1023; + C = C >>> 8 ^ T0[(C ^ (240 | c >> 8 & 7)) & 255]; + C = C >>> 8 ^ T0[(C ^ (128 | c >> 2 & 63)) & 255]; + C = C >>> 8 ^ T0[(C ^ (128 | d >> 6 & 15 | (c & 3) << 4)) & 255]; + C = C >>> 8 ^ T0[(C ^ (128 | d & 63)) & 255]; + } else { + C = C >>> 8 ^ T0[(C ^ (224 | c >> 12 & 15)) & 255]; + C = C >>> 8 ^ T0[(C ^ (128 | c >> 6 & 63)) & 255]; + C = C >>> 8 ^ T0[(C ^ (128 | c & 63)) & 255]; + } + } + return ~C; + } + CRC322.table = T0; + CRC322.bstr = crc32_bstr; + CRC322.buf = crc32_buf; + CRC322.str = crc32_str; + }); + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/utils/common.js +var require_common = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/utils/common.js"(exports2) { + "use strict"; + init_polyfill_buffer(); + var TYPED_OK = typeof Uint8Array !== "undefined" && typeof Uint16Array !== "undefined" && typeof Int32Array !== "undefined"; + function _has(obj, key2) { + return Object.prototype.hasOwnProperty.call(obj, key2); + } + exports2.assign = function(obj) { + var sources = Array.prototype.slice.call(arguments, 1); + while (sources.length) { + var source = sources.shift(); + if (!source) { + continue; + } + if (typeof source !== "object") { + throw new TypeError(source + "must be non-object"); + } + for (var p in source) { + if (_has(source, p)) { + obj[p] = source[p]; + } + } + } + return obj; + }; + exports2.shrinkBuf = function(buf, size) { + if (buf.length === size) { + return buf; + } + if (buf.subarray) { + return buf.subarray(0, size); + } + buf.length = size; + return buf; + }; + var fnTyped = { + arraySet: function(dest, src, src_offs, len, dest_offs) { + if (src.subarray && dest.subarray) { + dest.set(src.subarray(src_offs, src_offs + len), dest_offs); + return; + } + for (var i = 0; i < len; i++) { + dest[dest_offs + i] = src[src_offs + i]; + } + }, + // Join array of chunks to single array. + flattenChunks: function(chunks) { + var i, l, len, pos, chunk, result; + len = 0; + for (i = 0, l = chunks.length; i < l; i++) { + len += chunks[i].length; + } + result = new Uint8Array(len); + pos = 0; + for (i = 0, l = chunks.length; i < l; i++) { + chunk = chunks[i]; + result.set(chunk, pos); + pos += chunk.length; + } + return result; + } + }; + var fnUntyped = { + arraySet: function(dest, src, src_offs, len, dest_offs) { + for (var i = 0; i < len; i++) { + dest[dest_offs + i] = src[src_offs + i]; + } + }, + // Join array of chunks to single array. + flattenChunks: function(chunks) { + return [].concat.apply([], chunks); + } + }; + exports2.setTyped = function(on) { + if (on) { + exports2.Buf8 = Uint8Array; + exports2.Buf16 = Uint16Array; + exports2.Buf32 = Int32Array; + exports2.assign(exports2, fnTyped); + } else { + exports2.Buf8 = Array; + exports2.Buf16 = Array; + exports2.Buf32 = Array; + exports2.assign(exports2, fnUntyped); + } + }; + exports2.setTyped(TYPED_OK); + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/trees.js +var require_trees = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/trees.js"(exports2) { + "use strict"; + init_polyfill_buffer(); + var utils = require_common(); + var Z_FIXED = 4; + var Z_BINARY = 0; + var Z_TEXT = 1; + var Z_UNKNOWN = 2; + function zero(buf) { + var len = buf.length; + while (--len >= 0) { + buf[len] = 0; + } + } + var STORED_BLOCK = 0; + var STATIC_TREES = 1; + var DYN_TREES = 2; + var MIN_MATCH = 3; + var MAX_MATCH = 258; + var LENGTH_CODES = 29; + var LITERALS = 256; + var L_CODES = LITERALS + 1 + LENGTH_CODES; + var D_CODES = 30; + var BL_CODES = 19; + var HEAP_SIZE = 2 * L_CODES + 1; + var MAX_BITS = 15; + var Buf_size = 16; + var MAX_BL_BITS = 7; + var END_BLOCK = 256; + var REP_3_6 = 16; + var REPZ_3_10 = 17; + var REPZ_11_138 = 18; + var extra_lbits = ( + /* extra bits for each length code */ + [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0] + ); + var extra_dbits = ( + /* extra bits for each distance code */ + [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13] + ); + var extra_blbits = ( + /* extra bits for each bit length code */ + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7] + ); + var bl_order = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]; + var DIST_CODE_LEN = 512; + var static_ltree = new Array((L_CODES + 2) * 2); + zero(static_ltree); + var static_dtree = new Array(D_CODES * 2); + zero(static_dtree); + var _dist_code = new Array(DIST_CODE_LEN); + zero(_dist_code); + var _length_code = new Array(MAX_MATCH - MIN_MATCH + 1); + zero(_length_code); + var base_length = new Array(LENGTH_CODES); + zero(base_length); + var base_dist = new Array(D_CODES); + zero(base_dist); + function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) { + this.static_tree = static_tree; + this.extra_bits = extra_bits; + this.extra_base = extra_base; + this.elems = elems; + this.max_length = max_length; + this.has_stree = static_tree && static_tree.length; + } + var static_l_desc; + var static_d_desc; + var static_bl_desc; + function TreeDesc(dyn_tree, stat_desc) { + this.dyn_tree = dyn_tree; + this.max_code = 0; + this.stat_desc = stat_desc; + } + function d_code(dist) { + return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)]; + } + function put_short(s, w) { + s.pending_buf[s.pending++] = w & 255; + s.pending_buf[s.pending++] = w >>> 8 & 255; + } + function send_bits(s, value, length) { + if (s.bi_valid > Buf_size - length) { + s.bi_buf |= value << s.bi_valid & 65535; + put_short(s, s.bi_buf); + s.bi_buf = value >> Buf_size - s.bi_valid; + s.bi_valid += length - Buf_size; + } else { + s.bi_buf |= value << s.bi_valid & 65535; + s.bi_valid += length; + } + } + function send_code(s, c, tree) { + send_bits( + s, + tree[c * 2], + tree[c * 2 + 1] + /*.Len*/ + ); + } + function bi_reverse(code, len) { + var res = 0; + do { + res |= code & 1; + code >>>= 1; + res <<= 1; + } while (--len > 0); + return res >>> 1; + } + function bi_flush(s) { + if (s.bi_valid === 16) { + put_short(s, s.bi_buf); + s.bi_buf = 0; + s.bi_valid = 0; + } else if (s.bi_valid >= 8) { + s.pending_buf[s.pending++] = s.bi_buf & 255; + s.bi_buf >>= 8; + s.bi_valid -= 8; + } + } + function gen_bitlen(s, desc) { + var tree = desc.dyn_tree; + var max_code = desc.max_code; + var stree = desc.stat_desc.static_tree; + var has_stree = desc.stat_desc.has_stree; + var extra = desc.stat_desc.extra_bits; + var base = desc.stat_desc.extra_base; + var max_length = desc.stat_desc.max_length; + var h; + var n, m; + var bits; + var xbits; + var f; + var overflow = 0; + for (bits = 0; bits <= MAX_BITS; bits++) { + s.bl_count[bits] = 0; + } + tree[s.heap[s.heap_max] * 2 + 1] = 0; + for (h = s.heap_max + 1; h < HEAP_SIZE; h++) { + n = s.heap[h]; + bits = tree[tree[n * 2 + 1] * 2 + 1] + 1; + if (bits > max_length) { + bits = max_length; + overflow++; + } + tree[n * 2 + 1] = bits; + if (n > max_code) { + continue; + } + s.bl_count[bits]++; + xbits = 0; + if (n >= base) { + xbits = extra[n - base]; + } + f = tree[n * 2]; + s.opt_len += f * (bits + xbits); + if (has_stree) { + s.static_len += f * (stree[n * 2 + 1] + xbits); + } + } + if (overflow === 0) { + return; + } + do { + bits = max_length - 1; + while (s.bl_count[bits] === 0) { + bits--; + } + s.bl_count[bits]--; + s.bl_count[bits + 1] += 2; + s.bl_count[max_length]--; + overflow -= 2; + } while (overflow > 0); + for (bits = max_length; bits !== 0; bits--) { + n = s.bl_count[bits]; + while (n !== 0) { + m = s.heap[--h]; + if (m > max_code) { + continue; + } + if (tree[m * 2 + 1] !== bits) { + s.opt_len += (bits - tree[m * 2 + 1]) * tree[m * 2]; + tree[m * 2 + 1] = bits; + } + n--; + } + } + } + function gen_codes(tree, max_code, bl_count) { + var next_code = new Array(MAX_BITS + 1); + var code = 0; + var bits; + var n; + for (bits = 1; bits <= MAX_BITS; bits++) { + next_code[bits] = code = code + bl_count[bits - 1] << 1; + } + for (n = 0; n <= max_code; n++) { + var len = tree[n * 2 + 1]; + if (len === 0) { + continue; + } + tree[n * 2] = bi_reverse(next_code[len]++, len); + } + } + function tr_static_init() { + var n; + var bits; + var length; + var code; + var dist; + var bl_count = new Array(MAX_BITS + 1); + length = 0; + for (code = 0; code < LENGTH_CODES - 1; code++) { + base_length[code] = length; + for (n = 0; n < 1 << extra_lbits[code]; n++) { + _length_code[length++] = code; + } + } + _length_code[length - 1] = code; + dist = 0; + for (code = 0; code < 16; code++) { + base_dist[code] = dist; + for (n = 0; n < 1 << extra_dbits[code]; n++) { + _dist_code[dist++] = code; + } + } + dist >>= 7; + for (; code < D_CODES; code++) { + base_dist[code] = dist << 7; + for (n = 0; n < 1 << extra_dbits[code] - 7; n++) { + _dist_code[256 + dist++] = code; + } + } + for (bits = 0; bits <= MAX_BITS; bits++) { + bl_count[bits] = 0; + } + n = 0; + while (n <= 143) { + static_ltree[n * 2 + 1] = 8; + n++; + bl_count[8]++; + } + while (n <= 255) { + static_ltree[n * 2 + 1] = 9; + n++; + bl_count[9]++; + } + while (n <= 279) { + static_ltree[n * 2 + 1] = 7; + n++; + bl_count[7]++; + } + while (n <= 287) { + static_ltree[n * 2 + 1] = 8; + n++; + bl_count[8]++; + } + gen_codes(static_ltree, L_CODES + 1, bl_count); + for (n = 0; n < D_CODES; n++) { + static_dtree[n * 2 + 1] = 5; + static_dtree[n * 2] = bi_reverse(n, 5); + } + static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS); + static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES, MAX_BITS); + static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS); + } + function init_block(s) { + var n; + for (n = 0; n < L_CODES; n++) { + s.dyn_ltree[n * 2] = 0; + } + for (n = 0; n < D_CODES; n++) { + s.dyn_dtree[n * 2] = 0; + } + for (n = 0; n < BL_CODES; n++) { + s.bl_tree[n * 2] = 0; + } + s.dyn_ltree[END_BLOCK * 2] = 1; + s.opt_len = s.static_len = 0; + s.last_lit = s.matches = 0; + } + function bi_windup(s) { + if (s.bi_valid > 8) { + put_short(s, s.bi_buf); + } else if (s.bi_valid > 0) { + s.pending_buf[s.pending++] = s.bi_buf; + } + s.bi_buf = 0; + s.bi_valid = 0; + } + function copy_block(s, buf, len, header) { + bi_windup(s); + if (header) { + put_short(s, len); + put_short(s, ~len); + } + utils.arraySet(s.pending_buf, s.window, buf, len, s.pending); + s.pending += len; + } + function smaller(tree, n, m, depth) { + var _n2 = n * 2; + var _m2 = m * 2; + return tree[_n2] < tree[_m2] || tree[_n2] === tree[_m2] && depth[n] <= depth[m]; + } + function pqdownheap(s, tree, k) { + var v = s.heap[k]; + var j = k << 1; + while (j <= s.heap_len) { + if (j < s.heap_len && smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) { + j++; + } + if (smaller(tree, v, s.heap[j], s.depth)) { + break; + } + s.heap[k] = s.heap[j]; + k = j; + j <<= 1; + } + s.heap[k] = v; + } + function compress_block(s, ltree, dtree) { + var dist; + var lc; + var lx = 0; + var code; + var extra; + if (s.last_lit !== 0) { + do { + dist = s.pending_buf[s.d_buf + lx * 2] << 8 | s.pending_buf[s.d_buf + lx * 2 + 1]; + lc = s.pending_buf[s.l_buf + lx]; + lx++; + if (dist === 0) { + send_code(s, lc, ltree); + } else { + code = _length_code[lc]; + send_code(s, code + LITERALS + 1, ltree); + extra = extra_lbits[code]; + if (extra !== 0) { + lc -= base_length[code]; + send_bits(s, lc, extra); + } + dist--; + code = d_code(dist); + send_code(s, code, dtree); + extra = extra_dbits[code]; + if (extra !== 0) { + dist -= base_dist[code]; + send_bits(s, dist, extra); + } + } + } while (lx < s.last_lit); + } + send_code(s, END_BLOCK, ltree); + } + function build_tree(s, desc) { + var tree = desc.dyn_tree; + var stree = desc.stat_desc.static_tree; + var has_stree = desc.stat_desc.has_stree; + var elems = desc.stat_desc.elems; + var n, m; + var max_code = -1; + var node; + s.heap_len = 0; + s.heap_max = HEAP_SIZE; + for (n = 0; n < elems; n++) { + if (tree[n * 2] !== 0) { + s.heap[++s.heap_len] = max_code = n; + s.depth[n] = 0; + } else { + tree[n * 2 + 1] = 0; + } + } + while (s.heap_len < 2) { + node = s.heap[++s.heap_len] = max_code < 2 ? ++max_code : 0; + tree[node * 2] = 1; + s.depth[node] = 0; + s.opt_len--; + if (has_stree) { + s.static_len -= stree[node * 2 + 1]; + } + } + desc.max_code = max_code; + for (n = s.heap_len >> 1; n >= 1; n--) { + pqdownheap(s, tree, n); + } + node = elems; + do { + n = s.heap[ + 1 + /*SMALLEST*/ + ]; + s.heap[ + 1 + /*SMALLEST*/ + ] = s.heap[s.heap_len--]; + pqdownheap( + s, + tree, + 1 + /*SMALLEST*/ + ); + m = s.heap[ + 1 + /*SMALLEST*/ + ]; + s.heap[--s.heap_max] = n; + s.heap[--s.heap_max] = m; + tree[node * 2] = tree[n * 2] + tree[m * 2]; + s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1; + tree[n * 2 + 1] = tree[m * 2 + 1] = node; + s.heap[ + 1 + /*SMALLEST*/ + ] = node++; + pqdownheap( + s, + tree, + 1 + /*SMALLEST*/ + ); + } while (s.heap_len >= 2); + s.heap[--s.heap_max] = s.heap[ + 1 + /*SMALLEST*/ + ]; + gen_bitlen(s, desc); + gen_codes(tree, max_code, s.bl_count); + } + function scan_tree(s, tree, max_code) { + var n; + var prevlen = -1; + var curlen; + var nextlen = tree[0 * 2 + 1]; + var count = 0; + var max_count = 7; + var min_count = 4; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } + tree[(max_code + 1) * 2 + 1] = 65535; + for (n = 0; n <= max_code; n++) { + curlen = nextlen; + nextlen = tree[(n + 1) * 2 + 1]; + if (++count < max_count && curlen === nextlen) { + continue; + } else if (count < min_count) { + s.bl_tree[curlen * 2] += count; + } else if (curlen !== 0) { + if (curlen !== prevlen) { + s.bl_tree[curlen * 2]++; + } + s.bl_tree[REP_3_6 * 2]++; + } else if (count <= 10) { + s.bl_tree[REPZ_3_10 * 2]++; + } else { + s.bl_tree[REPZ_11_138 * 2]++; + } + count = 0; + prevlen = curlen; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } else if (curlen === nextlen) { + max_count = 6; + min_count = 3; + } else { + max_count = 7; + min_count = 4; + } + } + } + function send_tree(s, tree, max_code) { + var n; + var prevlen = -1; + var curlen; + var nextlen = tree[0 * 2 + 1]; + var count = 0; + var max_count = 7; + var min_count = 4; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } + for (n = 0; n <= max_code; n++) { + curlen = nextlen; + nextlen = tree[(n + 1) * 2 + 1]; + if (++count < max_count && curlen === nextlen) { + continue; + } else if (count < min_count) { + do { + send_code(s, curlen, s.bl_tree); + } while (--count !== 0); + } else if (curlen !== 0) { + if (curlen !== prevlen) { + send_code(s, curlen, s.bl_tree); + count--; + } + send_code(s, REP_3_6, s.bl_tree); + send_bits(s, count - 3, 2); + } else if (count <= 10) { + send_code(s, REPZ_3_10, s.bl_tree); + send_bits(s, count - 3, 3); + } else { + send_code(s, REPZ_11_138, s.bl_tree); + send_bits(s, count - 11, 7); + } + count = 0; + prevlen = curlen; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } else if (curlen === nextlen) { + max_count = 6; + min_count = 3; + } else { + max_count = 7; + min_count = 4; + } + } + } + function build_bl_tree(s) { + var max_blindex; + scan_tree(s, s.dyn_ltree, s.l_desc.max_code); + scan_tree(s, s.dyn_dtree, s.d_desc.max_code); + build_tree(s, s.bl_desc); + for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) { + if (s.bl_tree[bl_order[max_blindex] * 2 + 1] !== 0) { + break; + } + } + s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4; + return max_blindex; + } + function send_all_trees(s, lcodes, dcodes, blcodes) { + var rank; + send_bits(s, lcodes - 257, 5); + send_bits(s, dcodes - 1, 5); + send_bits(s, blcodes - 4, 4); + for (rank = 0; rank < blcodes; rank++) { + send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1], 3); + } + send_tree(s, s.dyn_ltree, lcodes - 1); + send_tree(s, s.dyn_dtree, dcodes - 1); + } + function detect_data_type(s) { + var black_mask = 4093624447; + var n; + for (n = 0; n <= 31; n++, black_mask >>>= 1) { + if (black_mask & 1 && s.dyn_ltree[n * 2] !== 0) { + return Z_BINARY; + } + } + if (s.dyn_ltree[9 * 2] !== 0 || s.dyn_ltree[10 * 2] !== 0 || s.dyn_ltree[13 * 2] !== 0) { + return Z_TEXT; + } + for (n = 32; n < LITERALS; n++) { + if (s.dyn_ltree[n * 2] !== 0) { + return Z_TEXT; + } + } + return Z_BINARY; + } + var static_init_done = false; + function _tr_init(s) { + if (!static_init_done) { + tr_static_init(); + static_init_done = true; + } + s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc); + s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc); + s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc); + s.bi_buf = 0; + s.bi_valid = 0; + init_block(s); + } + function _tr_stored_block(s, buf, stored_len, last2) { + send_bits(s, (STORED_BLOCK << 1) + (last2 ? 1 : 0), 3); + copy_block(s, buf, stored_len, true); + } + function _tr_align(s) { + send_bits(s, STATIC_TREES << 1, 3); + send_code(s, END_BLOCK, static_ltree); + bi_flush(s); + } + function _tr_flush_block(s, buf, stored_len, last2) { + var opt_lenb, static_lenb; + var max_blindex = 0; + if (s.level > 0) { + if (s.strm.data_type === Z_UNKNOWN) { + s.strm.data_type = detect_data_type(s); + } + build_tree(s, s.l_desc); + build_tree(s, s.d_desc); + max_blindex = build_bl_tree(s); + opt_lenb = s.opt_len + 3 + 7 >>> 3; + static_lenb = s.static_len + 3 + 7 >>> 3; + if (static_lenb <= opt_lenb) { + opt_lenb = static_lenb; + } + } else { + opt_lenb = static_lenb = stored_len + 5; + } + if (stored_len + 4 <= opt_lenb && buf !== -1) { + _tr_stored_block(s, buf, stored_len, last2); + } else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) { + send_bits(s, (STATIC_TREES << 1) + (last2 ? 1 : 0), 3); + compress_block(s, static_ltree, static_dtree); + } else { + send_bits(s, (DYN_TREES << 1) + (last2 ? 1 : 0), 3); + send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1); + compress_block(s, s.dyn_ltree, s.dyn_dtree); + } + init_block(s); + if (last2) { + bi_windup(s); + } + } + function _tr_tally(s, dist, lc) { + s.pending_buf[s.d_buf + s.last_lit * 2] = dist >>> 8 & 255; + s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 255; + s.pending_buf[s.l_buf + s.last_lit] = lc & 255; + s.last_lit++; + if (dist === 0) { + s.dyn_ltree[lc * 2]++; + } else { + s.matches++; + dist--; + s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2]++; + s.dyn_dtree[d_code(dist) * 2]++; + } + return s.last_lit === s.lit_bufsize - 1; + } + exports2._tr_init = _tr_init; + exports2._tr_stored_block = _tr_stored_block; + exports2._tr_flush_block = _tr_flush_block; + exports2._tr_tally = _tr_tally; + exports2._tr_align = _tr_align; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/adler32.js +var require_adler32 = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/adler32.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + function adler32(adler, buf, len, pos) { + var s1 = adler & 65535 | 0, s2 = adler >>> 16 & 65535 | 0, n = 0; + while (len !== 0) { + n = len > 2e3 ? 2e3 : len; + len -= n; + do { + s1 = s1 + buf[pos++] | 0; + s2 = s2 + s1 | 0; + } while (--n); + s1 %= 65521; + s2 %= 65521; + } + return s1 | s2 << 16 | 0; + } + module2.exports = adler32; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/crc32.js +var require_crc322 = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/crc32.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + function makeTable() { + var c, table = []; + for (var n = 0; n < 256; n++) { + c = n; + for (var k = 0; k < 8; k++) { + c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1; + } + table[n] = c; + } + return table; + } + var crcTable = makeTable(); + function crc322(crc, buf, len, pos) { + var t = crcTable, end = pos + len; + crc ^= -1; + for (var i = pos; i < end; i++) { + crc = crc >>> 8 ^ t[(crc ^ buf[i]) & 255]; + } + return crc ^ -1; + } + module2.exports = crc322; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/messages.js +var require_messages = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/messages.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + module2.exports = { + 2: "need dictionary", + /* Z_NEED_DICT 2 */ + 1: "stream end", + /* Z_STREAM_END 1 */ + 0: "", + /* Z_OK 0 */ + "-1": "file error", + /* Z_ERRNO (-1) */ + "-2": "stream error", + /* Z_STREAM_ERROR (-2) */ + "-3": "data error", + /* Z_DATA_ERROR (-3) */ + "-4": "insufficient memory", + /* Z_MEM_ERROR (-4) */ + "-5": "buffer error", + /* Z_BUF_ERROR (-5) */ + "-6": "incompatible version" + /* Z_VERSION_ERROR (-6) */ + }; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/deflate.js +var require_deflate = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/deflate.js"(exports2) { + "use strict"; + init_polyfill_buffer(); + var utils = require_common(); + var trees = require_trees(); + var adler32 = require_adler32(); + var crc322 = require_crc322(); + var msg = require_messages(); + var Z_NO_FLUSH = 0; + var Z_PARTIAL_FLUSH = 1; + var Z_FULL_FLUSH = 3; + var Z_FINISH = 4; + var Z_BLOCK = 5; + var Z_OK = 0; + var Z_STREAM_END = 1; + var Z_STREAM_ERROR = -2; + var Z_DATA_ERROR = -3; + var Z_BUF_ERROR = -5; + var Z_DEFAULT_COMPRESSION = -1; + var Z_FILTERED = 1; + var Z_HUFFMAN_ONLY = 2; + var Z_RLE = 3; + var Z_FIXED = 4; + var Z_DEFAULT_STRATEGY = 0; + var Z_UNKNOWN = 2; + var Z_DEFLATED = 8; + var MAX_MEM_LEVEL = 9; + var MAX_WBITS = 15; + var DEF_MEM_LEVEL = 8; + var LENGTH_CODES = 29; + var LITERALS = 256; + var L_CODES = LITERALS + 1 + LENGTH_CODES; + var D_CODES = 30; + var BL_CODES = 19; + var HEAP_SIZE = 2 * L_CODES + 1; + var MAX_BITS = 15; + var MIN_MATCH = 3; + var MAX_MATCH = 258; + var MIN_LOOKAHEAD = MAX_MATCH + MIN_MATCH + 1; + var PRESET_DICT = 32; + var INIT_STATE = 42; + var EXTRA_STATE = 69; + var NAME_STATE = 73; + var COMMENT_STATE = 91; + var HCRC_STATE = 103; + var BUSY_STATE = 113; + var FINISH_STATE = 666; + var BS_NEED_MORE = 1; + var BS_BLOCK_DONE = 2; + var BS_FINISH_STARTED = 3; + var BS_FINISH_DONE = 4; + var OS_CODE = 3; + function err(strm, errorCode) { + strm.msg = msg[errorCode]; + return errorCode; + } + function rank(f) { + return (f << 1) - (f > 4 ? 9 : 0); + } + function zero(buf) { + var len = buf.length; + while (--len >= 0) { + buf[len] = 0; + } + } + function flush_pending(strm) { + var s = strm.state; + var len = s.pending; + if (len > strm.avail_out) { + len = strm.avail_out; + } + if (len === 0) { + return; + } + utils.arraySet(strm.output, s.pending_buf, s.pending_out, len, strm.next_out); + strm.next_out += len; + s.pending_out += len; + strm.total_out += len; + strm.avail_out -= len; + s.pending -= len; + if (s.pending === 0) { + s.pending_out = 0; + } + } + function flush_block_only(s, last2) { + trees._tr_flush_block(s, s.block_start >= 0 ? s.block_start : -1, s.strstart - s.block_start, last2); + s.block_start = s.strstart; + flush_pending(s.strm); + } + function put_byte(s, b) { + s.pending_buf[s.pending++] = b; + } + function putShortMSB(s, b) { + s.pending_buf[s.pending++] = b >>> 8 & 255; + s.pending_buf[s.pending++] = b & 255; + } + function read_buf(strm, buf, start, size) { + var len = strm.avail_in; + if (len > size) { + len = size; + } + if (len === 0) { + return 0; + } + strm.avail_in -= len; + utils.arraySet(buf, strm.input, strm.next_in, len, start); + if (strm.state.wrap === 1) { + strm.adler = adler32(strm.adler, buf, len, start); + } else if (strm.state.wrap === 2) { + strm.adler = crc322(strm.adler, buf, len, start); + } + strm.next_in += len; + strm.total_in += len; + return len; + } + function longest_match(s, cur_match) { + var chain_length = s.max_chain_length; + var scan = s.strstart; + var match; + var len; + var best_len = s.prev_length; + var nice_match = s.nice_match; + var limit = s.strstart > s.w_size - MIN_LOOKAHEAD ? s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0; + var _win = s.window; + var wmask = s.w_mask; + var prev = s.prev; + var strend = s.strstart + MAX_MATCH; + var scan_end1 = _win[scan + best_len - 1]; + var scan_end = _win[scan + best_len]; + if (s.prev_length >= s.good_match) { + chain_length >>= 2; + } + if (nice_match > s.lookahead) { + nice_match = s.lookahead; + } + do { + match = cur_match; + if (_win[match + best_len] !== scan_end || _win[match + best_len - 1] !== scan_end1 || _win[match] !== _win[scan] || _win[++match] !== _win[scan + 1]) { + continue; + } + scan += 2; + match++; + do { + } while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && scan < strend); + len = MAX_MATCH - (strend - scan); + scan = strend - MAX_MATCH; + if (len > best_len) { + s.match_start = cur_match; + best_len = len; + if (len >= nice_match) { + break; + } + scan_end1 = _win[scan + best_len - 1]; + scan_end = _win[scan + best_len]; + } + } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0); + if (best_len <= s.lookahead) { + return best_len; + } + return s.lookahead; + } + function fill_window(s) { + var _w_size = s.w_size; + var p, n, m, more, str; + do { + more = s.window_size - s.lookahead - s.strstart; + if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) { + utils.arraySet(s.window, s.window, _w_size, _w_size, 0); + s.match_start -= _w_size; + s.strstart -= _w_size; + s.block_start -= _w_size; + n = s.hash_size; + p = n; + do { + m = s.head[--p]; + s.head[p] = m >= _w_size ? m - _w_size : 0; + } while (--n); + n = _w_size; + p = n; + do { + m = s.prev[--p]; + s.prev[p] = m >= _w_size ? m - _w_size : 0; + } while (--n); + more += _w_size; + } + if (s.strm.avail_in === 0) { + break; + } + n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more); + s.lookahead += n; + if (s.lookahead + s.insert >= MIN_MATCH) { + str = s.strstart - s.insert; + s.ins_h = s.window[str]; + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + 1]) & s.hash_mask; + while (s.insert) { + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask; + s.prev[str & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = str; + str++; + s.insert--; + if (s.lookahead + s.insert < MIN_MATCH) { + break; + } + } + } + } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0); + } + function deflate_stored(s, flush2) { + var max_block_size = 65535; + if (max_block_size > s.pending_buf_size - 5) { + max_block_size = s.pending_buf_size - 5; + } + for (; ; ) { + if (s.lookahead <= 1) { + fill_window(s); + if (s.lookahead === 0 && flush2 === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { + break; + } + } + s.strstart += s.lookahead; + s.lookahead = 0; + var max_start = s.block_start + max_block_size; + if (s.strstart === 0 || s.strstart >= max_start) { + s.lookahead = s.strstart - max_start; + s.strstart = max_start; + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + if (s.strstart - s.block_start >= s.w_size - MIN_LOOKAHEAD) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + } + s.insert = 0; + if (flush2 === Z_FINISH) { + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + return BS_FINISH_DONE; + } + if (s.strstart > s.block_start) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + return BS_NEED_MORE; + } + function deflate_fast(s, flush2) { + var hash_head; + var bflush; + for (; ; ) { + if (s.lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s.lookahead < MIN_LOOKAHEAD && flush2 === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { + break; + } + } + hash_head = 0; + if (s.lookahead >= MIN_MATCH) { + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + } + if (hash_head !== 0 && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) { + s.match_length = longest_match(s, hash_head); + } + if (s.match_length >= MIN_MATCH) { + bflush = trees._tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH); + s.lookahead -= s.match_length; + if (s.match_length <= s.max_lazy_match && s.lookahead >= MIN_MATCH) { + s.match_length--; + do { + s.strstart++; + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + } while (--s.match_length !== 0); + s.strstart++; + } else { + s.strstart += s.match_length; + s.match_length = 0; + s.ins_h = s.window[s.strstart]; + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + 1]) & s.hash_mask; + } + } else { + bflush = trees._tr_tally(s, 0, s.window[s.strstart]); + s.lookahead--; + s.strstart++; + } + if (bflush) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + } + s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1; + if (flush2 === Z_FINISH) { + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + return BS_FINISH_DONE; + } + if (s.last_lit) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + return BS_BLOCK_DONE; + } + function deflate_slow(s, flush2) { + var hash_head; + var bflush; + var max_insert; + for (; ; ) { + if (s.lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s.lookahead < MIN_LOOKAHEAD && flush2 === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { + break; + } + } + hash_head = 0; + if (s.lookahead >= MIN_MATCH) { + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + } + s.prev_length = s.match_length; + s.prev_match = s.match_start; + s.match_length = MIN_MATCH - 1; + if (hash_head !== 0 && s.prev_length < s.max_lazy_match && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) { + s.match_length = longest_match(s, hash_head); + if (s.match_length <= 5 && (s.strategy === Z_FILTERED || s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096)) { + s.match_length = MIN_MATCH - 1; + } + } + if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) { + max_insert = s.strstart + s.lookahead - MIN_MATCH; + bflush = trees._tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH); + s.lookahead -= s.prev_length - 1; + s.prev_length -= 2; + do { + if (++s.strstart <= max_insert) { + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + } + } while (--s.prev_length !== 0); + s.match_available = 0; + s.match_length = MIN_MATCH - 1; + s.strstart++; + if (bflush) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + } else if (s.match_available) { + bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]); + if (bflush) { + flush_block_only(s, false); + } + s.strstart++; + s.lookahead--; + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } else { + s.match_available = 1; + s.strstart++; + s.lookahead--; + } + } + if (s.match_available) { + bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]); + s.match_available = 0; + } + s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1; + if (flush2 === Z_FINISH) { + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + return BS_FINISH_DONE; + } + if (s.last_lit) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + return BS_BLOCK_DONE; + } + function deflate_rle(s, flush2) { + var bflush; + var prev; + var scan, strend; + var _win = s.window; + for (; ; ) { + if (s.lookahead <= MAX_MATCH) { + fill_window(s); + if (s.lookahead <= MAX_MATCH && flush2 === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { + break; + } + } + s.match_length = 0; + if (s.lookahead >= MIN_MATCH && s.strstart > 0) { + scan = s.strstart - 1; + prev = _win[scan]; + if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) { + strend = s.strstart + MAX_MATCH; + do { + } while (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && scan < strend); + s.match_length = MAX_MATCH - (strend - scan); + if (s.match_length > s.lookahead) { + s.match_length = s.lookahead; + } + } + } + if (s.match_length >= MIN_MATCH) { + bflush = trees._tr_tally(s, 1, s.match_length - MIN_MATCH); + s.lookahead -= s.match_length; + s.strstart += s.match_length; + s.match_length = 0; + } else { + bflush = trees._tr_tally(s, 0, s.window[s.strstart]); + s.lookahead--; + s.strstart++; + } + if (bflush) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + } + s.insert = 0; + if (flush2 === Z_FINISH) { + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + return BS_FINISH_DONE; + } + if (s.last_lit) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + return BS_BLOCK_DONE; + } + function deflate_huff(s, flush2) { + var bflush; + for (; ; ) { + if (s.lookahead === 0) { + fill_window(s); + if (s.lookahead === 0) { + if (flush2 === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + break; + } + } + s.match_length = 0; + bflush = trees._tr_tally(s, 0, s.window[s.strstart]); + s.lookahead--; + s.strstart++; + if (bflush) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + } + s.insert = 0; + if (flush2 === Z_FINISH) { + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + return BS_FINISH_DONE; + } + if (s.last_lit) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + return BS_BLOCK_DONE; + } + function Config(good_length, max_lazy, nice_length, max_chain, func) { + this.good_length = good_length; + this.max_lazy = max_lazy; + this.nice_length = nice_length; + this.max_chain = max_chain; + this.func = func; + } + var configuration_table; + configuration_table = [ + /* good lazy nice chain */ + new Config(0, 0, 0, 0, deflate_stored), + /* 0 store only */ + new Config(4, 4, 8, 4, deflate_fast), + /* 1 max speed, no lazy matches */ + new Config(4, 5, 16, 8, deflate_fast), + /* 2 */ + new Config(4, 6, 32, 32, deflate_fast), + /* 3 */ + new Config(4, 4, 16, 16, deflate_slow), + /* 4 lazy matches */ + new Config(8, 16, 32, 32, deflate_slow), + /* 5 */ + new Config(8, 16, 128, 128, deflate_slow), + /* 6 */ + new Config(8, 32, 128, 256, deflate_slow), + /* 7 */ + new Config(32, 128, 258, 1024, deflate_slow), + /* 8 */ + new Config(32, 258, 258, 4096, deflate_slow) + /* 9 max compression */ + ]; + function lm_init(s) { + s.window_size = 2 * s.w_size; + zero(s.head); + s.max_lazy_match = configuration_table[s.level].max_lazy; + s.good_match = configuration_table[s.level].good_length; + s.nice_match = configuration_table[s.level].nice_length; + s.max_chain_length = configuration_table[s.level].max_chain; + s.strstart = 0; + s.block_start = 0; + s.lookahead = 0; + s.insert = 0; + s.match_length = s.prev_length = MIN_MATCH - 1; + s.match_available = 0; + s.ins_h = 0; + } + function DeflateState() { + this.strm = null; + this.status = 0; + this.pending_buf = null; + this.pending_buf_size = 0; + this.pending_out = 0; + this.pending = 0; + this.wrap = 0; + this.gzhead = null; + this.gzindex = 0; + this.method = Z_DEFLATED; + this.last_flush = -1; + this.w_size = 0; + this.w_bits = 0; + this.w_mask = 0; + this.window = null; + this.window_size = 0; + this.prev = null; + this.head = null; + this.ins_h = 0; + this.hash_size = 0; + this.hash_bits = 0; + this.hash_mask = 0; + this.hash_shift = 0; + this.block_start = 0; + this.match_length = 0; + this.prev_match = 0; + this.match_available = 0; + this.strstart = 0; + this.match_start = 0; + this.lookahead = 0; + this.prev_length = 0; + this.max_chain_length = 0; + this.max_lazy_match = 0; + this.level = 0; + this.strategy = 0; + this.good_match = 0; + this.nice_match = 0; + this.dyn_ltree = new utils.Buf16(HEAP_SIZE * 2); + this.dyn_dtree = new utils.Buf16((2 * D_CODES + 1) * 2); + this.bl_tree = new utils.Buf16((2 * BL_CODES + 1) * 2); + zero(this.dyn_ltree); + zero(this.dyn_dtree); + zero(this.bl_tree); + this.l_desc = null; + this.d_desc = null; + this.bl_desc = null; + this.bl_count = new utils.Buf16(MAX_BITS + 1); + this.heap = new utils.Buf16(2 * L_CODES + 1); + zero(this.heap); + this.heap_len = 0; + this.heap_max = 0; + this.depth = new utils.Buf16(2 * L_CODES + 1); + zero(this.depth); + this.l_buf = 0; + this.lit_bufsize = 0; + this.last_lit = 0; + this.d_buf = 0; + this.opt_len = 0; + this.static_len = 0; + this.matches = 0; + this.insert = 0; + this.bi_buf = 0; + this.bi_valid = 0; + } + function deflateResetKeep(strm) { + var s; + if (!strm || !strm.state) { + return err(strm, Z_STREAM_ERROR); + } + strm.total_in = strm.total_out = 0; + strm.data_type = Z_UNKNOWN; + s = strm.state; + s.pending = 0; + s.pending_out = 0; + if (s.wrap < 0) { + s.wrap = -s.wrap; + } + s.status = s.wrap ? INIT_STATE : BUSY_STATE; + strm.adler = s.wrap === 2 ? 0 : 1; + s.last_flush = Z_NO_FLUSH; + trees._tr_init(s); + return Z_OK; + } + function deflateReset(strm) { + var ret = deflateResetKeep(strm); + if (ret === Z_OK) { + lm_init(strm.state); + } + return ret; + } + function deflateSetHeader(strm, head) { + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + if (strm.state.wrap !== 2) { + return Z_STREAM_ERROR; + } + strm.state.gzhead = head; + return Z_OK; + } + function deflateInit2(strm, level, method2, windowBits, memLevel, strategy) { + if (!strm) { + return Z_STREAM_ERROR; + } + var wrap = 1; + if (level === Z_DEFAULT_COMPRESSION) { + level = 6; + } + if (windowBits < 0) { + wrap = 0; + windowBits = -windowBits; + } else if (windowBits > 15) { + wrap = 2; + windowBits -= 16; + } + if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method2 !== Z_DEFLATED || windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) { + return err(strm, Z_STREAM_ERROR); + } + if (windowBits === 8) { + windowBits = 9; + } + var s = new DeflateState(); + strm.state = s; + s.strm = strm; + s.wrap = wrap; + s.gzhead = null; + s.w_bits = windowBits; + s.w_size = 1 << s.w_bits; + s.w_mask = s.w_size - 1; + s.hash_bits = memLevel + 7; + s.hash_size = 1 << s.hash_bits; + s.hash_mask = s.hash_size - 1; + s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH); + s.window = new utils.Buf8(s.w_size * 2); + s.head = new utils.Buf16(s.hash_size); + s.prev = new utils.Buf16(s.w_size); + s.lit_bufsize = 1 << memLevel + 6; + s.pending_buf_size = s.lit_bufsize * 4; + s.pending_buf = new utils.Buf8(s.pending_buf_size); + s.d_buf = 1 * s.lit_bufsize; + s.l_buf = (1 + 2) * s.lit_bufsize; + s.level = level; + s.strategy = strategy; + s.method = method2; + return deflateReset(strm); + } + function deflateInit(strm, level) { + return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY); + } + function deflate2(strm, flush2) { + var old_flush, s; + var beg, val; + if (!strm || !strm.state || flush2 > Z_BLOCK || flush2 < 0) { + return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR; + } + s = strm.state; + if (!strm.output || !strm.input && strm.avail_in !== 0 || s.status === FINISH_STATE && flush2 !== Z_FINISH) { + return err(strm, strm.avail_out === 0 ? Z_BUF_ERROR : Z_STREAM_ERROR); + } + s.strm = strm; + old_flush = s.last_flush; + s.last_flush = flush2; + if (s.status === INIT_STATE) { + if (s.wrap === 2) { + strm.adler = 0; + put_byte(s, 31); + put_byte(s, 139); + put_byte(s, 8); + if (!s.gzhead) { + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0); + put_byte(s, OS_CODE); + s.status = BUSY_STATE; + } else { + put_byte( + s, + (s.gzhead.text ? 1 : 0) + (s.gzhead.hcrc ? 2 : 0) + (!s.gzhead.extra ? 0 : 4) + (!s.gzhead.name ? 0 : 8) + (!s.gzhead.comment ? 0 : 16) + ); + put_byte(s, s.gzhead.time & 255); + put_byte(s, s.gzhead.time >> 8 & 255); + put_byte(s, s.gzhead.time >> 16 & 255); + put_byte(s, s.gzhead.time >> 24 & 255); + put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0); + put_byte(s, s.gzhead.os & 255); + if (s.gzhead.extra && s.gzhead.extra.length) { + put_byte(s, s.gzhead.extra.length & 255); + put_byte(s, s.gzhead.extra.length >> 8 & 255); + } + if (s.gzhead.hcrc) { + strm.adler = crc322(strm.adler, s.pending_buf, s.pending, 0); + } + s.gzindex = 0; + s.status = EXTRA_STATE; + } + } else { + var header = Z_DEFLATED + (s.w_bits - 8 << 4) << 8; + var level_flags = -1; + if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) { + level_flags = 0; + } else if (s.level < 6) { + level_flags = 1; + } else if (s.level === 6) { + level_flags = 2; + } else { + level_flags = 3; + } + header |= level_flags << 6; + if (s.strstart !== 0) { + header |= PRESET_DICT; + } + header += 31 - header % 31; + s.status = BUSY_STATE; + putShortMSB(s, header); + if (s.strstart !== 0) { + putShortMSB(s, strm.adler >>> 16); + putShortMSB(s, strm.adler & 65535); + } + strm.adler = 1; + } + } + if (s.status === EXTRA_STATE) { + if (s.gzhead.extra) { + beg = s.pending; + while (s.gzindex < (s.gzhead.extra.length & 65535)) { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc322(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + break; + } + } + put_byte(s, s.gzhead.extra[s.gzindex] & 255); + s.gzindex++; + } + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc322(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (s.gzindex === s.gzhead.extra.length) { + s.gzindex = 0; + s.status = NAME_STATE; + } + } else { + s.status = NAME_STATE; + } + } + if (s.status === NAME_STATE) { + if (s.gzhead.name) { + beg = s.pending; + do { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc322(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + val = 1; + break; + } + } + if (s.gzindex < s.gzhead.name.length) { + val = s.gzhead.name.charCodeAt(s.gzindex++) & 255; + } else { + val = 0; + } + put_byte(s, val); + } while (val !== 0); + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc322(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (val === 0) { + s.gzindex = 0; + s.status = COMMENT_STATE; + } + } else { + s.status = COMMENT_STATE; + } + } + if (s.status === COMMENT_STATE) { + if (s.gzhead.comment) { + beg = s.pending; + do { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc322(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + val = 1; + break; + } + } + if (s.gzindex < s.gzhead.comment.length) { + val = s.gzhead.comment.charCodeAt(s.gzindex++) & 255; + } else { + val = 0; + } + put_byte(s, val); + } while (val !== 0); + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc322(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (val === 0) { + s.status = HCRC_STATE; + } + } else { + s.status = HCRC_STATE; + } + } + if (s.status === HCRC_STATE) { + if (s.gzhead.hcrc) { + if (s.pending + 2 > s.pending_buf_size) { + flush_pending(strm); + } + if (s.pending + 2 <= s.pending_buf_size) { + put_byte(s, strm.adler & 255); + put_byte(s, strm.adler >> 8 & 255); + strm.adler = 0; + s.status = BUSY_STATE; + } + } else { + s.status = BUSY_STATE; + } + } + if (s.pending !== 0) { + flush_pending(strm); + if (strm.avail_out === 0) { + s.last_flush = -1; + return Z_OK; + } + } else if (strm.avail_in === 0 && rank(flush2) <= rank(old_flush) && flush2 !== Z_FINISH) { + return err(strm, Z_BUF_ERROR); + } + if (s.status === FINISH_STATE && strm.avail_in !== 0) { + return err(strm, Z_BUF_ERROR); + } + if (strm.avail_in !== 0 || s.lookahead !== 0 || flush2 !== Z_NO_FLUSH && s.status !== FINISH_STATE) { + var bstate = s.strategy === Z_HUFFMAN_ONLY ? deflate_huff(s, flush2) : s.strategy === Z_RLE ? deflate_rle(s, flush2) : configuration_table[s.level].func(s, flush2); + if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) { + s.status = FINISH_STATE; + } + if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) { + if (strm.avail_out === 0) { + s.last_flush = -1; + } + return Z_OK; + } + if (bstate === BS_BLOCK_DONE) { + if (flush2 === Z_PARTIAL_FLUSH) { + trees._tr_align(s); + } else if (flush2 !== Z_BLOCK) { + trees._tr_stored_block(s, 0, 0, false); + if (flush2 === Z_FULL_FLUSH) { + zero(s.head); + if (s.lookahead === 0) { + s.strstart = 0; + s.block_start = 0; + s.insert = 0; + } + } + } + flush_pending(strm); + if (strm.avail_out === 0) { + s.last_flush = -1; + return Z_OK; + } + } + } + if (flush2 !== Z_FINISH) { + return Z_OK; + } + if (s.wrap <= 0) { + return Z_STREAM_END; + } + if (s.wrap === 2) { + put_byte(s, strm.adler & 255); + put_byte(s, strm.adler >> 8 & 255); + put_byte(s, strm.adler >> 16 & 255); + put_byte(s, strm.adler >> 24 & 255); + put_byte(s, strm.total_in & 255); + put_byte(s, strm.total_in >> 8 & 255); + put_byte(s, strm.total_in >> 16 & 255); + put_byte(s, strm.total_in >> 24 & 255); + } else { + putShortMSB(s, strm.adler >>> 16); + putShortMSB(s, strm.adler & 65535); + } + flush_pending(strm); + if (s.wrap > 0) { + s.wrap = -s.wrap; + } + return s.pending !== 0 ? Z_OK : Z_STREAM_END; + } + function deflateEnd(strm) { + var status2; + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + status2 = strm.state.status; + if (status2 !== INIT_STATE && status2 !== EXTRA_STATE && status2 !== NAME_STATE && status2 !== COMMENT_STATE && status2 !== HCRC_STATE && status2 !== BUSY_STATE && status2 !== FINISH_STATE) { + return err(strm, Z_STREAM_ERROR); + } + strm.state = null; + return status2 === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK; + } + function deflateSetDictionary(strm, dictionary) { + var dictLength = dictionary.length; + var s; + var str, n; + var wrap; + var avail; + var next; + var input; + var tmpDict; + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + s = strm.state; + wrap = s.wrap; + if (wrap === 2 || wrap === 1 && s.status !== INIT_STATE || s.lookahead) { + return Z_STREAM_ERROR; + } + if (wrap === 1) { + strm.adler = adler32(strm.adler, dictionary, dictLength, 0); + } + s.wrap = 0; + if (dictLength >= s.w_size) { + if (wrap === 0) { + zero(s.head); + s.strstart = 0; + s.block_start = 0; + s.insert = 0; + } + tmpDict = new utils.Buf8(s.w_size); + utils.arraySet(tmpDict, dictionary, dictLength - s.w_size, s.w_size, 0); + dictionary = tmpDict; + dictLength = s.w_size; + } + avail = strm.avail_in; + next = strm.next_in; + input = strm.input; + strm.avail_in = dictLength; + strm.next_in = 0; + strm.input = dictionary; + fill_window(s); + while (s.lookahead >= MIN_MATCH) { + str = s.strstart; + n = s.lookahead - (MIN_MATCH - 1); + do { + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask; + s.prev[str & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = str; + str++; + } while (--n); + s.strstart = str; + s.lookahead = MIN_MATCH - 1; + fill_window(s); + } + s.strstart += s.lookahead; + s.block_start = s.strstart; + s.insert = s.lookahead; + s.lookahead = 0; + s.match_length = s.prev_length = MIN_MATCH - 1; + s.match_available = 0; + strm.next_in = next; + strm.input = input; + strm.avail_in = avail; + s.wrap = wrap; + return Z_OK; + } + exports2.deflateInit = deflateInit; + exports2.deflateInit2 = deflateInit2; + exports2.deflateReset = deflateReset; + exports2.deflateResetKeep = deflateResetKeep; + exports2.deflateSetHeader = deflateSetHeader; + exports2.deflate = deflate2; + exports2.deflateEnd = deflateEnd; + exports2.deflateSetDictionary = deflateSetDictionary; + exports2.deflateInfo = "pako deflate (from Nodeca project)"; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/utils/strings.js +var require_strings = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/utils/strings.js"(exports2) { + "use strict"; + init_polyfill_buffer(); + var utils = require_common(); + var STR_APPLY_OK = true; + var STR_APPLY_UIA_OK = true; + try { + String.fromCharCode.apply(null, [0]); + } catch (__) { + STR_APPLY_OK = false; + } + try { + String.fromCharCode.apply(null, new Uint8Array(1)); + } catch (__) { + STR_APPLY_UIA_OK = false; + } + var _utf8len = new utils.Buf8(256); + for (q = 0; q < 256; q++) { + _utf8len[q] = q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1; + } + var q; + _utf8len[254] = _utf8len[254] = 1; + exports2.string2buf = function(str) { + var buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0; + for (m_pos = 0; m_pos < str_len; m_pos++) { + c = str.charCodeAt(m_pos); + if ((c & 64512) === 55296 && m_pos + 1 < str_len) { + c2 = str.charCodeAt(m_pos + 1); + if ((c2 & 64512) === 56320) { + c = 65536 + (c - 55296 << 10) + (c2 - 56320); + m_pos++; + } + } + buf_len += c < 128 ? 1 : c < 2048 ? 2 : c < 65536 ? 3 : 4; + } + buf = new utils.Buf8(buf_len); + for (i = 0, m_pos = 0; i < buf_len; m_pos++) { + c = str.charCodeAt(m_pos); + if ((c & 64512) === 55296 && m_pos + 1 < str_len) { + c2 = str.charCodeAt(m_pos + 1); + if ((c2 & 64512) === 56320) { + c = 65536 + (c - 55296 << 10) + (c2 - 56320); + m_pos++; + } + } + if (c < 128) { + buf[i++] = c; + } else if (c < 2048) { + buf[i++] = 192 | c >>> 6; + buf[i++] = 128 | c & 63; + } else if (c < 65536) { + buf[i++] = 224 | c >>> 12; + buf[i++] = 128 | c >>> 6 & 63; + buf[i++] = 128 | c & 63; + } else { + buf[i++] = 240 | c >>> 18; + buf[i++] = 128 | c >>> 12 & 63; + buf[i++] = 128 | c >>> 6 & 63; + buf[i++] = 128 | c & 63; + } + } + return buf; + }; + function buf2binstring(buf, len) { + if (len < 65534) { + if (buf.subarray && STR_APPLY_UIA_OK || !buf.subarray && STR_APPLY_OK) { + return String.fromCharCode.apply(null, utils.shrinkBuf(buf, len)); + } + } + var result = ""; + for (var i = 0; i < len; i++) { + result += String.fromCharCode(buf[i]); + } + return result; + } + exports2.buf2binstring = function(buf) { + return buf2binstring(buf, buf.length); + }; + exports2.binstring2buf = function(str) { + var buf = new utils.Buf8(str.length); + for (var i = 0, len = buf.length; i < len; i++) { + buf[i] = str.charCodeAt(i); + } + return buf; + }; + exports2.buf2string = function(buf, max) { + var i, out, c, c_len; + var len = max || buf.length; + var utf16buf = new Array(len * 2); + for (out = 0, i = 0; i < len; ) { + c = buf[i++]; + if (c < 128) { + utf16buf[out++] = c; + continue; + } + c_len = _utf8len[c]; + if (c_len > 4) { + utf16buf[out++] = 65533; + i += c_len - 1; + continue; + } + c &= c_len === 2 ? 31 : c_len === 3 ? 15 : 7; + while (c_len > 1 && i < len) { + c = c << 6 | buf[i++] & 63; + c_len--; + } + if (c_len > 1) { + utf16buf[out++] = 65533; + continue; + } + if (c < 65536) { + utf16buf[out++] = c; + } else { + c -= 65536; + utf16buf[out++] = 55296 | c >> 10 & 1023; + utf16buf[out++] = 56320 | c & 1023; + } + } + return buf2binstring(utf16buf, out); + }; + exports2.utf8border = function(buf, max) { + var pos; + max = max || buf.length; + if (max > buf.length) { + max = buf.length; + } + pos = max - 1; + while (pos >= 0 && (buf[pos] & 192) === 128) { + pos--; + } + if (pos < 0) { + return max; + } + if (pos === 0) { + return max; + } + return pos + _utf8len[buf[pos]] > max ? pos : max; + }; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/zstream.js +var require_zstream = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/zstream.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + function ZStream() { + this.input = null; + this.next_in = 0; + this.avail_in = 0; + this.total_in = 0; + this.output = null; + this.next_out = 0; + this.avail_out = 0; + this.total_out = 0; + this.msg = ""; + this.state = null; + this.data_type = 2; + this.adler = 0; + } + module2.exports = ZStream; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/deflate.js +var require_deflate2 = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/deflate.js"(exports2) { + "use strict"; + init_polyfill_buffer(); + var zlib_deflate = require_deflate(); + var utils = require_common(); + var strings = require_strings(); + var msg = require_messages(); + var ZStream = require_zstream(); + var toString = Object.prototype.toString; + var Z_NO_FLUSH = 0; + var Z_FINISH = 4; + var Z_OK = 0; + var Z_STREAM_END = 1; + var Z_SYNC_FLUSH = 2; + var Z_DEFAULT_COMPRESSION = -1; + var Z_DEFAULT_STRATEGY = 0; + var Z_DEFLATED = 8; + function Deflate(options) { + if (!(this instanceof Deflate)) + return new Deflate(options); + this.options = utils.assign({ + level: Z_DEFAULT_COMPRESSION, + method: Z_DEFLATED, + chunkSize: 16384, + windowBits: 15, + memLevel: 8, + strategy: Z_DEFAULT_STRATEGY, + to: "" + }, options || {}); + var opt = this.options; + if (opt.raw && opt.windowBits > 0) { + opt.windowBits = -opt.windowBits; + } else if (opt.gzip && opt.windowBits > 0 && opt.windowBits < 16) { + opt.windowBits += 16; + } + this.err = 0; + this.msg = ""; + this.ended = false; + this.chunks = []; + this.strm = new ZStream(); + this.strm.avail_out = 0; + var status2 = zlib_deflate.deflateInit2( + this.strm, + opt.level, + opt.method, + opt.windowBits, + opt.memLevel, + opt.strategy + ); + if (status2 !== Z_OK) { + throw new Error(msg[status2]); + } + if (opt.header) { + zlib_deflate.deflateSetHeader(this.strm, opt.header); + } + if (opt.dictionary) { + var dict; + if (typeof opt.dictionary === "string") { + dict = strings.string2buf(opt.dictionary); + } else if (toString.call(opt.dictionary) === "[object ArrayBuffer]") { + dict = new Uint8Array(opt.dictionary); + } else { + dict = opt.dictionary; + } + status2 = zlib_deflate.deflateSetDictionary(this.strm, dict); + if (status2 !== Z_OK) { + throw new Error(msg[status2]); + } + this._dict_set = true; + } + } + Deflate.prototype.push = function(data, mode) { + var strm = this.strm; + var chunkSize = this.options.chunkSize; + var status2, _mode; + if (this.ended) { + return false; + } + _mode = mode === ~~mode ? mode : mode === true ? Z_FINISH : Z_NO_FLUSH; + if (typeof data === "string") { + strm.input = strings.string2buf(data); + } else if (toString.call(data) === "[object ArrayBuffer]") { + strm.input = new Uint8Array(data); + } else { + strm.input = data; + } + strm.next_in = 0; + strm.avail_in = strm.input.length; + do { + if (strm.avail_out === 0) { + strm.output = new utils.Buf8(chunkSize); + strm.next_out = 0; + strm.avail_out = chunkSize; + } + status2 = zlib_deflate.deflate(strm, _mode); + if (status2 !== Z_STREAM_END && status2 !== Z_OK) { + this.onEnd(status2); + this.ended = true; + return false; + } + if (strm.avail_out === 0 || strm.avail_in === 0 && (_mode === Z_FINISH || _mode === Z_SYNC_FLUSH)) { + if (this.options.to === "string") { + this.onData(strings.buf2binstring(utils.shrinkBuf(strm.output, strm.next_out))); + } else { + this.onData(utils.shrinkBuf(strm.output, strm.next_out)); + } + } + } while ((strm.avail_in > 0 || strm.avail_out === 0) && status2 !== Z_STREAM_END); + if (_mode === Z_FINISH) { + status2 = zlib_deflate.deflateEnd(this.strm); + this.onEnd(status2); + this.ended = true; + return status2 === Z_OK; + } + if (_mode === Z_SYNC_FLUSH) { + this.onEnd(Z_OK); + strm.avail_out = 0; + return true; + } + return true; + }; + Deflate.prototype.onData = function(chunk) { + this.chunks.push(chunk); + }; + Deflate.prototype.onEnd = function(status2) { + if (status2 === Z_OK) { + if (this.options.to === "string") { + this.result = this.chunks.join(""); + } else { + this.result = utils.flattenChunks(this.chunks); + } + } + this.chunks = []; + this.err = status2; + this.msg = this.strm.msg; + }; + function deflate2(input, options) { + var deflator = new Deflate(options); + deflator.push(input, true); + if (deflator.err) { + throw deflator.msg || msg[deflator.err]; + } + return deflator.result; + } + function deflateRaw(input, options) { + options = options || {}; + options.raw = true; + return deflate2(input, options); + } + function gzip(input, options) { + options = options || {}; + options.gzip = true; + return deflate2(input, options); + } + exports2.Deflate = Deflate; + exports2.deflate = deflate2; + exports2.deflateRaw = deflateRaw; + exports2.gzip = gzip; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/inffast.js +var require_inffast = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/inffast.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var BAD = 30; + var TYPE = 12; + module2.exports = function inflate_fast(strm, start) { + var state; + var _in; + var last2; + var _out; + var beg; + var end; + var dmax; + var wsize; + var whave; + var wnext; + var s_window; + var hold; + var bits; + var lcode; + var dcode; + var lmask; + var dmask; + var here; + var op; + var len; + var dist; + var from; + var from_source; + var input, output; + state = strm.state; + _in = strm.next_in; + input = strm.input; + last2 = _in + (strm.avail_in - 5); + _out = strm.next_out; + output = strm.output; + beg = _out - (start - strm.avail_out); + end = _out + (strm.avail_out - 257); + dmax = state.dmax; + wsize = state.wsize; + whave = state.whave; + wnext = state.wnext; + s_window = state.window; + hold = state.hold; + bits = state.bits; + lcode = state.lencode; + dcode = state.distcode; + lmask = (1 << state.lenbits) - 1; + dmask = (1 << state.distbits) - 1; + top: + do { + if (bits < 15) { + hold += input[_in++] << bits; + bits += 8; + hold += input[_in++] << bits; + bits += 8; + } + here = lcode[hold & lmask]; + dolen: + for (; ; ) { + op = here >>> 24; + hold >>>= op; + bits -= op; + op = here >>> 16 & 255; + if (op === 0) { + output[_out++] = here & 65535; + } else if (op & 16) { + len = here & 65535; + op &= 15; + if (op) { + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + } + len += hold & (1 << op) - 1; + hold >>>= op; + bits -= op; + } + if (bits < 15) { + hold += input[_in++] << bits; + bits += 8; + hold += input[_in++] << bits; + bits += 8; + } + here = dcode[hold & dmask]; + dodist: + for (; ; ) { + op = here >>> 24; + hold >>>= op; + bits -= op; + op = here >>> 16 & 255; + if (op & 16) { + dist = here & 65535; + op &= 15; + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + } + } + dist += hold & (1 << op) - 1; + if (dist > dmax) { + strm.msg = "invalid distance too far back"; + state.mode = BAD; + break top; + } + hold >>>= op; + bits -= op; + op = _out - beg; + if (dist > op) { + op = dist - op; + if (op > whave) { + if (state.sane) { + strm.msg = "invalid distance too far back"; + state.mode = BAD; + break top; + } + } + from = 0; + from_source = s_window; + if (wnext === 0) { + from += wsize - op; + if (op < len) { + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; + from_source = output; + } + } else if (wnext < op) { + from += wsize + wnext - op; + op -= wnext; + if (op < len) { + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = 0; + if (wnext < len) { + op = wnext; + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; + from_source = output; + } + } + } else { + from += wnext - op; + if (op < len) { + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; + from_source = output; + } + } + while (len > 2) { + output[_out++] = from_source[from++]; + output[_out++] = from_source[from++]; + output[_out++] = from_source[from++]; + len -= 3; + } + if (len) { + output[_out++] = from_source[from++]; + if (len > 1) { + output[_out++] = from_source[from++]; + } + } + } else { + from = _out - dist; + do { + output[_out++] = output[from++]; + output[_out++] = output[from++]; + output[_out++] = output[from++]; + len -= 3; + } while (len > 2); + if (len) { + output[_out++] = output[from++]; + if (len > 1) { + output[_out++] = output[from++]; + } + } + } + } else if ((op & 64) === 0) { + here = dcode[(here & 65535) + (hold & (1 << op) - 1)]; + continue dodist; + } else { + strm.msg = "invalid distance code"; + state.mode = BAD; + break top; + } + break; + } + } else if ((op & 64) === 0) { + here = lcode[(here & 65535) + (hold & (1 << op) - 1)]; + continue dolen; + } else if (op & 32) { + state.mode = TYPE; + break top; + } else { + strm.msg = "invalid literal/length code"; + state.mode = BAD; + break top; + } + break; + } + } while (_in < last2 && _out < end); + len = bits >> 3; + _in -= len; + bits -= len << 3; + hold &= (1 << bits) - 1; + strm.next_in = _in; + strm.next_out = _out; + strm.avail_in = _in < last2 ? 5 + (last2 - _in) : 5 - (_in - last2); + strm.avail_out = _out < end ? 257 + (end - _out) : 257 - (_out - end); + state.hold = hold; + state.bits = bits; + return; + }; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/inftrees.js +var require_inftrees = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/inftrees.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var utils = require_common(); + var MAXBITS = 15; + var ENOUGH_LENS = 852; + var ENOUGH_DISTS = 592; + var CODES = 0; + var LENS = 1; + var DISTS = 2; + var lbase = [ + /* Length codes 257..285 base */ + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 13, + 15, + 17, + 19, + 23, + 27, + 31, + 35, + 43, + 51, + 59, + 67, + 83, + 99, + 115, + 131, + 163, + 195, + 227, + 258, + 0, + 0 + ]; + var lext = [ + /* Length codes 257..285 extra */ + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 17, + 17, + 17, + 17, + 18, + 18, + 18, + 18, + 19, + 19, + 19, + 19, + 20, + 20, + 20, + 20, + 21, + 21, + 21, + 21, + 16, + 72, + 78 + ]; + var dbase = [ + /* Distance codes 0..29 base */ + 1, + 2, + 3, + 4, + 5, + 7, + 9, + 13, + 17, + 25, + 33, + 49, + 65, + 97, + 129, + 193, + 257, + 385, + 513, + 769, + 1025, + 1537, + 2049, + 3073, + 4097, + 6145, + 8193, + 12289, + 16385, + 24577, + 0, + 0 + ]; + var dext = [ + /* Distance codes 0..29 extra */ + 16, + 16, + 16, + 16, + 17, + 17, + 18, + 18, + 19, + 19, + 20, + 20, + 21, + 21, + 22, + 22, + 23, + 23, + 24, + 24, + 25, + 25, + 26, + 26, + 27, + 27, + 28, + 28, + 29, + 29, + 64, + 64 + ]; + module2.exports = function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts) { + var bits = opts.bits; + var len = 0; + var sym = 0; + var min = 0, max = 0; + var root2 = 0; + var curr = 0; + var drop = 0; + var left = 0; + var used = 0; + var huff = 0; + var incr; + var fill; + var low; + var mask; + var next; + var base = null; + var base_index = 0; + var end; + var count = new utils.Buf16(MAXBITS + 1); + var offs = new utils.Buf16(MAXBITS + 1); + var extra = null; + var extra_index = 0; + var here_bits, here_op, here_val; + for (len = 0; len <= MAXBITS; len++) { + count[len] = 0; + } + for (sym = 0; sym < codes; sym++) { + count[lens[lens_index + sym]]++; + } + root2 = bits; + for (max = MAXBITS; max >= 1; max--) { + if (count[max] !== 0) { + break; + } + } + if (root2 > max) { + root2 = max; + } + if (max === 0) { + table[table_index++] = 1 << 24 | 64 << 16 | 0; + table[table_index++] = 1 << 24 | 64 << 16 | 0; + opts.bits = 1; + return 0; + } + for (min = 1; min < max; min++) { + if (count[min] !== 0) { + break; + } + } + if (root2 < min) { + root2 = min; + } + left = 1; + for (len = 1; len <= MAXBITS; len++) { + left <<= 1; + left -= count[len]; + if (left < 0) { + return -1; + } + } + if (left > 0 && (type === CODES || max !== 1)) { + return -1; + } + offs[1] = 0; + for (len = 1; len < MAXBITS; len++) { + offs[len + 1] = offs[len] + count[len]; + } + for (sym = 0; sym < codes; sym++) { + if (lens[lens_index + sym] !== 0) { + work[offs[lens[lens_index + sym]]++] = sym; + } + } + if (type === CODES) { + base = extra = work; + end = 19; + } else if (type === LENS) { + base = lbase; + base_index -= 257; + extra = lext; + extra_index -= 257; + end = 256; + } else { + base = dbase; + extra = dext; + end = -1; + } + huff = 0; + sym = 0; + len = min; + next = table_index; + curr = root2; + drop = 0; + low = -1; + used = 1 << root2; + mask = used - 1; + if (type === LENS && used > ENOUGH_LENS || type === DISTS && used > ENOUGH_DISTS) { + return 1; + } + for (; ; ) { + here_bits = len - drop; + if (work[sym] < end) { + here_op = 0; + here_val = work[sym]; + } else if (work[sym] > end) { + here_op = extra[extra_index + work[sym]]; + here_val = base[base_index + work[sym]]; + } else { + here_op = 32 + 64; + here_val = 0; + } + incr = 1 << len - drop; + fill = 1 << curr; + min = fill; + do { + fill -= incr; + table[next + (huff >> drop) + fill] = here_bits << 24 | here_op << 16 | here_val | 0; + } while (fill !== 0); + incr = 1 << len - 1; + while (huff & incr) { + incr >>= 1; + } + if (incr !== 0) { + huff &= incr - 1; + huff += incr; + } else { + huff = 0; + } + sym++; + if (--count[len] === 0) { + if (len === max) { + break; + } + len = lens[lens_index + work[sym]]; + } + if (len > root2 && (huff & mask) !== low) { + if (drop === 0) { + drop = root2; + } + next += min; + curr = len - drop; + left = 1 << curr; + while (curr + drop < max) { + left -= count[curr + drop]; + if (left <= 0) { + break; + } + curr++; + left <<= 1; + } + used += 1 << curr; + if (type === LENS && used > ENOUGH_LENS || type === DISTS && used > ENOUGH_DISTS) { + return 1; + } + low = huff & mask; + table[low] = root2 << 24 | curr << 16 | next - table_index | 0; + } + } + if (huff !== 0) { + table[next + huff] = len - drop << 24 | 64 << 16 | 0; + } + opts.bits = root2; + return 0; + }; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/inflate.js +var require_inflate = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/inflate.js"(exports2) { + "use strict"; + init_polyfill_buffer(); + var utils = require_common(); + var adler32 = require_adler32(); + var crc322 = require_crc322(); + var inflate_fast = require_inffast(); + var inflate_table = require_inftrees(); + var CODES = 0; + var LENS = 1; + var DISTS = 2; + var Z_FINISH = 4; + var Z_BLOCK = 5; + var Z_TREES = 6; + var Z_OK = 0; + var Z_STREAM_END = 1; + var Z_NEED_DICT = 2; + var Z_STREAM_ERROR = -2; + var Z_DATA_ERROR = -3; + var Z_MEM_ERROR = -4; + var Z_BUF_ERROR = -5; + var Z_DEFLATED = 8; + var HEAD = 1; + var FLAGS = 2; + var TIME = 3; + var OS = 4; + var EXLEN = 5; + var EXTRA2 = 6; + var NAME = 7; + var COMMENT = 8; + var HCRC = 9; + var DICTID = 10; + var DICT = 11; + var TYPE = 12; + var TYPEDO = 13; + var STORED = 14; + var COPY_ = 15; + var COPY = 16; + var TABLE = 17; + var LENLENS = 18; + var CODELENS = 19; + var LEN_ = 20; + var LEN = 21; + var LENEXT = 22; + var DIST = 23; + var DISTEXT = 24; + var MATCH = 25; + var LIT = 26; + var CHECK = 27; + var LENGTH = 28; + var DONE = 29; + var BAD = 30; + var MEM = 31; + var SYNC = 32; + var ENOUGH_LENS = 852; + var ENOUGH_DISTS = 592; + var MAX_WBITS = 15; + var DEF_WBITS = MAX_WBITS; + function zswap32(q) { + return (q >>> 24 & 255) + (q >>> 8 & 65280) + ((q & 65280) << 8) + ((q & 255) << 24); + } + function InflateState() { + this.mode = 0; + this.last = false; + this.wrap = 0; + this.havedict = false; + this.flags = 0; + this.dmax = 0; + this.check = 0; + this.total = 0; + this.head = null; + this.wbits = 0; + this.wsize = 0; + this.whave = 0; + this.wnext = 0; + this.window = null; + this.hold = 0; + this.bits = 0; + this.length = 0; + this.offset = 0; + this.extra = 0; + this.lencode = null; + this.distcode = null; + this.lenbits = 0; + this.distbits = 0; + this.ncode = 0; + this.nlen = 0; + this.ndist = 0; + this.have = 0; + this.next = null; + this.lens = new utils.Buf16(320); + this.work = new utils.Buf16(288); + this.lendyn = null; + this.distdyn = null; + this.sane = 0; + this.back = 0; + this.was = 0; + } + function inflateResetKeep(strm) { + var state; + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + state = strm.state; + strm.total_in = strm.total_out = state.total = 0; + strm.msg = ""; + if (state.wrap) { + strm.adler = state.wrap & 1; + } + state.mode = HEAD; + state.last = 0; + state.havedict = 0; + state.dmax = 32768; + state.head = null; + state.hold = 0; + state.bits = 0; + state.lencode = state.lendyn = new utils.Buf32(ENOUGH_LENS); + state.distcode = state.distdyn = new utils.Buf32(ENOUGH_DISTS); + state.sane = 1; + state.back = -1; + return Z_OK; + } + function inflateReset(strm) { + var state; + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + state = strm.state; + state.wsize = 0; + state.whave = 0; + state.wnext = 0; + return inflateResetKeep(strm); + } + function inflateReset2(strm, windowBits) { + var wrap; + var state; + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + state = strm.state; + if (windowBits < 0) { + wrap = 0; + windowBits = -windowBits; + } else { + wrap = (windowBits >> 4) + 1; + if (windowBits < 48) { + windowBits &= 15; + } + } + if (windowBits && (windowBits < 8 || windowBits > 15)) { + return Z_STREAM_ERROR; + } + if (state.window !== null && state.wbits !== windowBits) { + state.window = null; + } + state.wrap = wrap; + state.wbits = windowBits; + return inflateReset(strm); + } + function inflateInit2(strm, windowBits) { + var ret; + var state; + if (!strm) { + return Z_STREAM_ERROR; + } + state = new InflateState(); + strm.state = state; + state.window = null; + ret = inflateReset2(strm, windowBits); + if (ret !== Z_OK) { + strm.state = null; + } + return ret; + } + function inflateInit(strm) { + return inflateInit2(strm, DEF_WBITS); + } + var virgin = true; + var lenfix; + var distfix; + function fixedtables(state) { + if (virgin) { + var sym; + lenfix = new utils.Buf32(512); + distfix = new utils.Buf32(32); + sym = 0; + while (sym < 144) { + state.lens[sym++] = 8; + } + while (sym < 256) { + state.lens[sym++] = 9; + } + while (sym < 280) { + state.lens[sym++] = 7; + } + while (sym < 288) { + state.lens[sym++] = 8; + } + inflate_table(LENS, state.lens, 0, 288, lenfix, 0, state.work, { bits: 9 }); + sym = 0; + while (sym < 32) { + state.lens[sym++] = 5; + } + inflate_table(DISTS, state.lens, 0, 32, distfix, 0, state.work, { bits: 5 }); + virgin = false; + } + state.lencode = lenfix; + state.lenbits = 9; + state.distcode = distfix; + state.distbits = 5; + } + function updatewindow(strm, src, end, copy2) { + var dist; + var state = strm.state; + if (state.window === null) { + state.wsize = 1 << state.wbits; + state.wnext = 0; + state.whave = 0; + state.window = new utils.Buf8(state.wsize); + } + if (copy2 >= state.wsize) { + utils.arraySet(state.window, src, end - state.wsize, state.wsize, 0); + state.wnext = 0; + state.whave = state.wsize; + } else { + dist = state.wsize - state.wnext; + if (dist > copy2) { + dist = copy2; + } + utils.arraySet(state.window, src, end - copy2, dist, state.wnext); + copy2 -= dist; + if (copy2) { + utils.arraySet(state.window, src, end - copy2, copy2, 0); + state.wnext = copy2; + state.whave = state.wsize; + } else { + state.wnext += dist; + if (state.wnext === state.wsize) { + state.wnext = 0; + } + if (state.whave < state.wsize) { + state.whave += dist; + } + } + } + return 0; + } + function inflate2(strm, flush2) { + var state; + var input, output; + var next; + var put; + var have, left; + var hold; + var bits; + var _in, _out; + var copy2; + var from; + var from_source; + var here = 0; + var here_bits, here_op, here_val; + var last_bits, last_op, last_val; + var len; + var ret; + var hbuf = new utils.Buf8(4); + var opts; + var n; + var order = ( + /* permutation of code lengths */ + [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15] + ); + if (!strm || !strm.state || !strm.output || !strm.input && strm.avail_in !== 0) { + return Z_STREAM_ERROR; + } + state = strm.state; + if (state.mode === TYPE) { + state.mode = TYPEDO; + } + put = strm.next_out; + output = strm.output; + left = strm.avail_out; + next = strm.next_in; + input = strm.input; + have = strm.avail_in; + hold = state.hold; + bits = state.bits; + _in = have; + _out = left; + ret = Z_OK; + inf_leave: + for (; ; ) { + switch (state.mode) { + case HEAD: + if (state.wrap === 0) { + state.mode = TYPEDO; + break; + } + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (state.wrap & 2 && hold === 35615) { + state.check = 0; + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + state.check = crc322(state.check, hbuf, 2, 0); + hold = 0; + bits = 0; + state.mode = FLAGS; + break; + } + state.flags = 0; + if (state.head) { + state.head.done = false; + } + if (!(state.wrap & 1) || /* check if zlib header allowed */ + (((hold & 255) << 8) + (hold >> 8)) % 31) { + strm.msg = "incorrect header check"; + state.mode = BAD; + break; + } + if ((hold & 15) !== Z_DEFLATED) { + strm.msg = "unknown compression method"; + state.mode = BAD; + break; + } + hold >>>= 4; + bits -= 4; + len = (hold & 15) + 8; + if (state.wbits === 0) { + state.wbits = len; + } else if (len > state.wbits) { + strm.msg = "invalid window size"; + state.mode = BAD; + break; + } + state.dmax = 1 << len; + strm.adler = state.check = 1; + state.mode = hold & 512 ? DICTID : TYPE; + hold = 0; + bits = 0; + break; + case FLAGS: + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.flags = hold; + if ((state.flags & 255) !== Z_DEFLATED) { + strm.msg = "unknown compression method"; + state.mode = BAD; + break; + } + if (state.flags & 57344) { + strm.msg = "unknown header flags set"; + state.mode = BAD; + break; + } + if (state.head) { + state.head.text = hold >> 8 & 1; + } + if (state.flags & 512) { + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + state.check = crc322(state.check, hbuf, 2, 0); + } + hold = 0; + bits = 0; + state.mode = TIME; + case TIME: + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (state.head) { + state.head.time = hold; + } + if (state.flags & 512) { + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + hbuf[2] = hold >>> 16 & 255; + hbuf[3] = hold >>> 24 & 255; + state.check = crc322(state.check, hbuf, 4, 0); + } + hold = 0; + bits = 0; + state.mode = OS; + case OS: + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (state.head) { + state.head.xflags = hold & 255; + state.head.os = hold >> 8; + } + if (state.flags & 512) { + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + state.check = crc322(state.check, hbuf, 2, 0); + } + hold = 0; + bits = 0; + state.mode = EXLEN; + case EXLEN: + if (state.flags & 1024) { + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.length = hold; + if (state.head) { + state.head.extra_len = hold; + } + if (state.flags & 512) { + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + state.check = crc322(state.check, hbuf, 2, 0); + } + hold = 0; + bits = 0; + } else if (state.head) { + state.head.extra = null; + } + state.mode = EXTRA2; + case EXTRA2: + if (state.flags & 1024) { + copy2 = state.length; + if (copy2 > have) { + copy2 = have; + } + if (copy2) { + if (state.head) { + len = state.head.extra_len - state.length; + if (!state.head.extra) { + state.head.extra = new Array(state.head.extra_len); + } + utils.arraySet( + state.head.extra, + input, + next, + // extra field is limited to 65536 bytes + // - no need for additional size check + copy2, + /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/ + len + ); + } + if (state.flags & 512) { + state.check = crc322(state.check, input, copy2, next); + } + have -= copy2; + next += copy2; + state.length -= copy2; + } + if (state.length) { + break inf_leave; + } + } + state.length = 0; + state.mode = NAME; + case NAME: + if (state.flags & 2048) { + if (have === 0) { + break inf_leave; + } + copy2 = 0; + do { + len = input[next + copy2++]; + if (state.head && len && state.length < 65536) { + state.head.name += String.fromCharCode(len); + } + } while (len && copy2 < have); + if (state.flags & 512) { + state.check = crc322(state.check, input, copy2, next); + } + have -= copy2; + next += copy2; + if (len) { + break inf_leave; + } + } else if (state.head) { + state.head.name = null; + } + state.length = 0; + state.mode = COMMENT; + case COMMENT: + if (state.flags & 4096) { + if (have === 0) { + break inf_leave; + } + copy2 = 0; + do { + len = input[next + copy2++]; + if (state.head && len && state.length < 65536) { + state.head.comment += String.fromCharCode(len); + } + } while (len && copy2 < have); + if (state.flags & 512) { + state.check = crc322(state.check, input, copy2, next); + } + have -= copy2; + next += copy2; + if (len) { + break inf_leave; + } + } else if (state.head) { + state.head.comment = null; + } + state.mode = HCRC; + case HCRC: + if (state.flags & 512) { + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (hold !== (state.check & 65535)) { + strm.msg = "header crc mismatch"; + state.mode = BAD; + break; + } + hold = 0; + bits = 0; + } + if (state.head) { + state.head.hcrc = state.flags >> 9 & 1; + state.head.done = true; + } + strm.adler = state.check = 0; + state.mode = TYPE; + break; + case DICTID: + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + strm.adler = state.check = zswap32(hold); + hold = 0; + bits = 0; + state.mode = DICT; + case DICT: + if (state.havedict === 0) { + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + return Z_NEED_DICT; + } + strm.adler = state.check = 1; + state.mode = TYPE; + case TYPE: + if (flush2 === Z_BLOCK || flush2 === Z_TREES) { + break inf_leave; + } + case TYPEDO: + if (state.last) { + hold >>>= bits & 7; + bits -= bits & 7; + state.mode = CHECK; + break; + } + while (bits < 3) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.last = hold & 1; + hold >>>= 1; + bits -= 1; + switch (hold & 3) { + case 0: + state.mode = STORED; + break; + case 1: + fixedtables(state); + state.mode = LEN_; + if (flush2 === Z_TREES) { + hold >>>= 2; + bits -= 2; + break inf_leave; + } + break; + case 2: + state.mode = TABLE; + break; + case 3: + strm.msg = "invalid block type"; + state.mode = BAD; + } + hold >>>= 2; + bits -= 2; + break; + case STORED: + hold >>>= bits & 7; + bits -= bits & 7; + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if ((hold & 65535) !== (hold >>> 16 ^ 65535)) { + strm.msg = "invalid stored block lengths"; + state.mode = BAD; + break; + } + state.length = hold & 65535; + hold = 0; + bits = 0; + state.mode = COPY_; + if (flush2 === Z_TREES) { + break inf_leave; + } + case COPY_: + state.mode = COPY; + case COPY: + copy2 = state.length; + if (copy2) { + if (copy2 > have) { + copy2 = have; + } + if (copy2 > left) { + copy2 = left; + } + if (copy2 === 0) { + break inf_leave; + } + utils.arraySet(output, input, next, copy2, put); + have -= copy2; + next += copy2; + left -= copy2; + put += copy2; + state.length -= copy2; + break; + } + state.mode = TYPE; + break; + case TABLE: + while (bits < 14) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.nlen = (hold & 31) + 257; + hold >>>= 5; + bits -= 5; + state.ndist = (hold & 31) + 1; + hold >>>= 5; + bits -= 5; + state.ncode = (hold & 15) + 4; + hold >>>= 4; + bits -= 4; + if (state.nlen > 286 || state.ndist > 30) { + strm.msg = "too many length or distance symbols"; + state.mode = BAD; + break; + } + state.have = 0; + state.mode = LENLENS; + case LENLENS: + while (state.have < state.ncode) { + while (bits < 3) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.lens[order[state.have++]] = hold & 7; + hold >>>= 3; + bits -= 3; + } + while (state.have < 19) { + state.lens[order[state.have++]] = 0; + } + state.lencode = state.lendyn; + state.lenbits = 7; + opts = { bits: state.lenbits }; + ret = inflate_table(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts); + state.lenbits = opts.bits; + if (ret) { + strm.msg = "invalid code lengths set"; + state.mode = BAD; + break; + } + state.have = 0; + state.mode = CODELENS; + case CODELENS: + while (state.have < state.nlen + state.ndist) { + for (; ; ) { + here = state.lencode[hold & (1 << state.lenbits) - 1]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (here_val < 16) { + hold >>>= here_bits; + bits -= here_bits; + state.lens[state.have++] = here_val; + } else { + if (here_val === 16) { + n = here_bits + 2; + while (bits < n) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= here_bits; + bits -= here_bits; + if (state.have === 0) { + strm.msg = "invalid bit length repeat"; + state.mode = BAD; + break; + } + len = state.lens[state.have - 1]; + copy2 = 3 + (hold & 3); + hold >>>= 2; + bits -= 2; + } else if (here_val === 17) { + n = here_bits + 3; + while (bits < n) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= here_bits; + bits -= here_bits; + len = 0; + copy2 = 3 + (hold & 7); + hold >>>= 3; + bits -= 3; + } else { + n = here_bits + 7; + while (bits < n) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= here_bits; + bits -= here_bits; + len = 0; + copy2 = 11 + (hold & 127); + hold >>>= 7; + bits -= 7; + } + if (state.have + copy2 > state.nlen + state.ndist) { + strm.msg = "invalid bit length repeat"; + state.mode = BAD; + break; + } + while (copy2--) { + state.lens[state.have++] = len; + } + } + } + if (state.mode === BAD) { + break; + } + if (state.lens[256] === 0) { + strm.msg = "invalid code -- missing end-of-block"; + state.mode = BAD; + break; + } + state.lenbits = 9; + opts = { bits: state.lenbits }; + ret = inflate_table(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts); + state.lenbits = opts.bits; + if (ret) { + strm.msg = "invalid literal/lengths set"; + state.mode = BAD; + break; + } + state.distbits = 6; + state.distcode = state.distdyn; + opts = { bits: state.distbits }; + ret = inflate_table(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts); + state.distbits = opts.bits; + if (ret) { + strm.msg = "invalid distances set"; + state.mode = BAD; + break; + } + state.mode = LEN_; + if (flush2 === Z_TREES) { + break inf_leave; + } + case LEN_: + state.mode = LEN; + case LEN: + if (have >= 6 && left >= 258) { + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + inflate_fast(strm, _out); + put = strm.next_out; + output = strm.output; + left = strm.avail_out; + next = strm.next_in; + input = strm.input; + have = strm.avail_in; + hold = state.hold; + bits = state.bits; + if (state.mode === TYPE) { + state.back = -1; + } + break; + } + state.back = 0; + for (; ; ) { + here = state.lencode[hold & (1 << state.lenbits) - 1]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (here_op && (here_op & 240) === 0) { + last_bits = here_bits; + last_op = here_op; + last_val = here_val; + for (; ; ) { + here = state.lencode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (last_bits + here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= last_bits; + bits -= last_bits; + state.back += last_bits; + } + hold >>>= here_bits; + bits -= here_bits; + state.back += here_bits; + state.length = here_val; + if (here_op === 0) { + state.mode = LIT; + break; + } + if (here_op & 32) { + state.back = -1; + state.mode = TYPE; + break; + } + if (here_op & 64) { + strm.msg = "invalid literal/length code"; + state.mode = BAD; + break; + } + state.extra = here_op & 15; + state.mode = LENEXT; + case LENEXT: + if (state.extra) { + n = state.extra; + while (bits < n) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.length += hold & (1 << state.extra) - 1; + hold >>>= state.extra; + bits -= state.extra; + state.back += state.extra; + } + state.was = state.length; + state.mode = DIST; + case DIST: + for (; ; ) { + here = state.distcode[hold & (1 << state.distbits) - 1]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if ((here_op & 240) === 0) { + last_bits = here_bits; + last_op = here_op; + last_val = here_val; + for (; ; ) { + here = state.distcode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (last_bits + here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= last_bits; + bits -= last_bits; + state.back += last_bits; + } + hold >>>= here_bits; + bits -= here_bits; + state.back += here_bits; + if (here_op & 64) { + strm.msg = "invalid distance code"; + state.mode = BAD; + break; + } + state.offset = here_val; + state.extra = here_op & 15; + state.mode = DISTEXT; + case DISTEXT: + if (state.extra) { + n = state.extra; + while (bits < n) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.offset += hold & (1 << state.extra) - 1; + hold >>>= state.extra; + bits -= state.extra; + state.back += state.extra; + } + if (state.offset > state.dmax) { + strm.msg = "invalid distance too far back"; + state.mode = BAD; + break; + } + state.mode = MATCH; + case MATCH: + if (left === 0) { + break inf_leave; + } + copy2 = _out - left; + if (state.offset > copy2) { + copy2 = state.offset - copy2; + if (copy2 > state.whave) { + if (state.sane) { + strm.msg = "invalid distance too far back"; + state.mode = BAD; + break; + } + } + if (copy2 > state.wnext) { + copy2 -= state.wnext; + from = state.wsize - copy2; + } else { + from = state.wnext - copy2; + } + if (copy2 > state.length) { + copy2 = state.length; + } + from_source = state.window; + } else { + from_source = output; + from = put - state.offset; + copy2 = state.length; + } + if (copy2 > left) { + copy2 = left; + } + left -= copy2; + state.length -= copy2; + do { + output[put++] = from_source[from++]; + } while (--copy2); + if (state.length === 0) { + state.mode = LEN; + } + break; + case LIT: + if (left === 0) { + break inf_leave; + } + output[put++] = state.length; + left--; + state.mode = LEN; + break; + case CHECK: + if (state.wrap) { + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold |= input[next++] << bits; + bits += 8; + } + _out -= left; + strm.total_out += _out; + state.total += _out; + if (_out) { + strm.adler = state.check = /*UPDATE(state.check, put - _out, _out);*/ + state.flags ? crc322(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out); + } + _out = left; + if ((state.flags ? hold : zswap32(hold)) !== state.check) { + strm.msg = "incorrect data check"; + state.mode = BAD; + break; + } + hold = 0; + bits = 0; + } + state.mode = LENGTH; + case LENGTH: + if (state.wrap && state.flags) { + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (hold !== (state.total & 4294967295)) { + strm.msg = "incorrect length check"; + state.mode = BAD; + break; + } + hold = 0; + bits = 0; + } + state.mode = DONE; + case DONE: + ret = Z_STREAM_END; + break inf_leave; + case BAD: + ret = Z_DATA_ERROR; + break inf_leave; + case MEM: + return Z_MEM_ERROR; + case SYNC: + default: + return Z_STREAM_ERROR; + } + } + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + if (state.wsize || _out !== strm.avail_out && state.mode < BAD && (state.mode < CHECK || flush2 !== Z_FINISH)) { + if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) { + state.mode = MEM; + return Z_MEM_ERROR; + } + } + _in -= strm.avail_in; + _out -= strm.avail_out; + strm.total_in += _in; + strm.total_out += _out; + state.total += _out; + if (state.wrap && _out) { + strm.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/ + state.flags ? crc322(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out); + } + strm.data_type = state.bits + (state.last ? 64 : 0) + (state.mode === TYPE ? 128 : 0) + (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0); + if ((_in === 0 && _out === 0 || flush2 === Z_FINISH) && ret === Z_OK) { + ret = Z_BUF_ERROR; + } + return ret; + } + function inflateEnd(strm) { + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + var state = strm.state; + if (state.window) { + state.window = null; + } + strm.state = null; + return Z_OK; + } + function inflateGetHeader(strm, head) { + var state; + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + state = strm.state; + if ((state.wrap & 2) === 0) { + return Z_STREAM_ERROR; + } + state.head = head; + head.done = false; + return Z_OK; + } + function inflateSetDictionary(strm, dictionary) { + var dictLength = dictionary.length; + var state; + var dictid; + var ret; + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + state = strm.state; + if (state.wrap !== 0 && state.mode !== DICT) { + return Z_STREAM_ERROR; + } + if (state.mode === DICT) { + dictid = 1; + dictid = adler32(dictid, dictionary, dictLength, 0); + if (dictid !== state.check) { + return Z_DATA_ERROR; + } + } + ret = updatewindow(strm, dictionary, dictLength, dictLength); + if (ret) { + state.mode = MEM; + return Z_MEM_ERROR; + } + state.havedict = 1; + return Z_OK; + } + exports2.inflateReset = inflateReset; + exports2.inflateReset2 = inflateReset2; + exports2.inflateResetKeep = inflateResetKeep; + exports2.inflateInit = inflateInit; + exports2.inflateInit2 = inflateInit2; + exports2.inflate = inflate2; + exports2.inflateEnd = inflateEnd; + exports2.inflateGetHeader = inflateGetHeader; + exports2.inflateSetDictionary = inflateSetDictionary; + exports2.inflateInfo = "pako inflate (from Nodeca project)"; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/constants.js +var require_constants = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/constants.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + module2.exports = { + /* Allowed flush values; see deflate() and inflate() below for details */ + Z_NO_FLUSH: 0, + Z_PARTIAL_FLUSH: 1, + Z_SYNC_FLUSH: 2, + Z_FULL_FLUSH: 3, + Z_FINISH: 4, + Z_BLOCK: 5, + Z_TREES: 6, + /* Return codes for the compression/decompression functions. Negative values + * are errors, positive values are used for special but normal events. + */ + Z_OK: 0, + Z_STREAM_END: 1, + Z_NEED_DICT: 2, + Z_ERRNO: -1, + Z_STREAM_ERROR: -2, + Z_DATA_ERROR: -3, + //Z_MEM_ERROR: -4, + Z_BUF_ERROR: -5, + //Z_VERSION_ERROR: -6, + /* compression levels */ + Z_NO_COMPRESSION: 0, + Z_BEST_SPEED: 1, + Z_BEST_COMPRESSION: 9, + Z_DEFAULT_COMPRESSION: -1, + Z_FILTERED: 1, + Z_HUFFMAN_ONLY: 2, + Z_RLE: 3, + Z_FIXED: 4, + Z_DEFAULT_STRATEGY: 0, + /* Possible values of the data_type field (though see inflate()) */ + Z_BINARY: 0, + Z_TEXT: 1, + //Z_ASCII: 1, // = Z_TEXT (deprecated) + Z_UNKNOWN: 2, + /* The deflate compression method */ + Z_DEFLATED: 8 + //Z_NULL: null // Use -1 or null inline, depending on var type + }; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/gzheader.js +var require_gzheader = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/gzheader.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + function GZheader() { + this.text = 0; + this.time = 0; + this.xflags = 0; + this.os = 0; + this.extra = null; + this.extra_len = 0; + this.name = ""; + this.comment = ""; + this.hcrc = 0; + this.done = false; + } + module2.exports = GZheader; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/inflate.js +var require_inflate2 = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/inflate.js"(exports2) { + "use strict"; + init_polyfill_buffer(); + var zlib_inflate = require_inflate(); + var utils = require_common(); + var strings = require_strings(); + var c = require_constants(); + var msg = require_messages(); + var ZStream = require_zstream(); + var GZheader = require_gzheader(); + var toString = Object.prototype.toString; + function Inflate(options) { + if (!(this instanceof Inflate)) + return new Inflate(options); + this.options = utils.assign({ + chunkSize: 16384, + windowBits: 0, + to: "" + }, options || {}); + var opt = this.options; + if (opt.raw && opt.windowBits >= 0 && opt.windowBits < 16) { + opt.windowBits = -opt.windowBits; + if (opt.windowBits === 0) { + opt.windowBits = -15; + } + } + if (opt.windowBits >= 0 && opt.windowBits < 16 && !(options && options.windowBits)) { + opt.windowBits += 32; + } + if (opt.windowBits > 15 && opt.windowBits < 48) { + if ((opt.windowBits & 15) === 0) { + opt.windowBits |= 15; + } + } + this.err = 0; + this.msg = ""; + this.ended = false; + this.chunks = []; + this.strm = new ZStream(); + this.strm.avail_out = 0; + var status2 = zlib_inflate.inflateInit2( + this.strm, + opt.windowBits + ); + if (status2 !== c.Z_OK) { + throw new Error(msg[status2]); + } + this.header = new GZheader(); + zlib_inflate.inflateGetHeader(this.strm, this.header); + if (opt.dictionary) { + if (typeof opt.dictionary === "string") { + opt.dictionary = strings.string2buf(opt.dictionary); + } else if (toString.call(opt.dictionary) === "[object ArrayBuffer]") { + opt.dictionary = new Uint8Array(opt.dictionary); + } + if (opt.raw) { + status2 = zlib_inflate.inflateSetDictionary(this.strm, opt.dictionary); + if (status2 !== c.Z_OK) { + throw new Error(msg[status2]); + } + } + } + } + Inflate.prototype.push = function(data, mode) { + var strm = this.strm; + var chunkSize = this.options.chunkSize; + var dictionary = this.options.dictionary; + var status2, _mode; + var next_out_utf8, tail, utf8str; + var allowBufError = false; + if (this.ended) { + return false; + } + _mode = mode === ~~mode ? mode : mode === true ? c.Z_FINISH : c.Z_NO_FLUSH; + if (typeof data === "string") { + strm.input = strings.binstring2buf(data); + } else if (toString.call(data) === "[object ArrayBuffer]") { + strm.input = new Uint8Array(data); + } else { + strm.input = data; + } + strm.next_in = 0; + strm.avail_in = strm.input.length; + do { + if (strm.avail_out === 0) { + strm.output = new utils.Buf8(chunkSize); + strm.next_out = 0; + strm.avail_out = chunkSize; + } + status2 = zlib_inflate.inflate(strm, c.Z_NO_FLUSH); + if (status2 === c.Z_NEED_DICT && dictionary) { + status2 = zlib_inflate.inflateSetDictionary(this.strm, dictionary); + } + if (status2 === c.Z_BUF_ERROR && allowBufError === true) { + status2 = c.Z_OK; + allowBufError = false; + } + if (status2 !== c.Z_STREAM_END && status2 !== c.Z_OK) { + this.onEnd(status2); + this.ended = true; + return false; + } + if (strm.next_out) { + if (strm.avail_out === 0 || status2 === c.Z_STREAM_END || strm.avail_in === 0 && (_mode === c.Z_FINISH || _mode === c.Z_SYNC_FLUSH)) { + if (this.options.to === "string") { + next_out_utf8 = strings.utf8border(strm.output, strm.next_out); + tail = strm.next_out - next_out_utf8; + utf8str = strings.buf2string(strm.output, next_out_utf8); + strm.next_out = tail; + strm.avail_out = chunkSize - tail; + if (tail) { + utils.arraySet(strm.output, strm.output, next_out_utf8, tail, 0); + } + this.onData(utf8str); + } else { + this.onData(utils.shrinkBuf(strm.output, strm.next_out)); + } + } + } + if (strm.avail_in === 0 && strm.avail_out === 0) { + allowBufError = true; + } + } while ((strm.avail_in > 0 || strm.avail_out === 0) && status2 !== c.Z_STREAM_END); + if (status2 === c.Z_STREAM_END) { + _mode = c.Z_FINISH; + } + if (_mode === c.Z_FINISH) { + status2 = zlib_inflate.inflateEnd(this.strm); + this.onEnd(status2); + this.ended = true; + return status2 === c.Z_OK; + } + if (_mode === c.Z_SYNC_FLUSH) { + this.onEnd(c.Z_OK); + strm.avail_out = 0; + return true; + } + return true; + }; + Inflate.prototype.onData = function(chunk) { + this.chunks.push(chunk); + }; + Inflate.prototype.onEnd = function(status2) { + if (status2 === c.Z_OK) { + if (this.options.to === "string") { + this.result = this.chunks.join(""); + } else { + this.result = utils.flattenChunks(this.chunks); + } + } + this.chunks = []; + this.err = status2; + this.msg = this.strm.msg; + }; + function inflate2(input, options) { + var inflator = new Inflate(options); + inflator.push(input, true); + if (inflator.err) { + throw inflator.msg || msg[inflator.err]; + } + return inflator.result; + } + function inflateRaw(input, options) { + options = options || {}; + options.raw = true; + return inflate2(input, options); + } + exports2.Inflate = Inflate; + exports2.inflate = inflate2; + exports2.inflateRaw = inflateRaw; + exports2.ungzip = inflate2; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/index.js +var require_pako = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var assign2 = require_common().assign; + var deflate2 = require_deflate2(); + var inflate2 = require_inflate2(); + var constants = require_constants(); + var pako2 = {}; + assign2(pako2, deflate2, inflate2, constants); + module2.exports = pako2; + } +}); + +// node_modules/.pnpm/pify@4.0.1/node_modules/pify/index.js +var require_pify = __commonJS({ + "node_modules/.pnpm/pify@4.0.1/node_modules/pify/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var processFn = (fn, options) => function(...args) { + const P = options.promiseModule; + return new P((resolve, reject) => { + if (options.multiArgs) { + args.push((...result) => { + if (options.errorFirst) { + if (result[0]) { + reject(result); + } else { + result.shift(); + resolve(result); + } + } else { + resolve(result); + } + }); + } else if (options.errorFirst) { + args.push((error, result) => { + if (error) { + reject(error); + } else { + resolve(result); + } + }); + } else { + args.push(resolve); + } + fn.apply(this, args); + }); + }; + module2.exports = (input, options) => { + options = Object.assign({ + exclude: [/.+(Sync|Stream)$/], + errorFirst: true, + promiseModule: Promise + }, options); + const objType = typeof input; + if (!(input !== null && (objType === "object" || objType === "function"))) { + throw new TypeError(`Expected \`input\` to be a \`Function\` or \`Object\`, got \`${input === null ? "null" : objType}\``); + } + const filter = (key2) => { + const match = (pattern) => typeof pattern === "string" ? key2 === pattern : pattern.test(key2); + return options.include ? options.include.some(match) : !options.exclude.some(match); + }; + let ret; + if (objType === "function") { + ret = function(...args) { + return options.excludeMain ? input(...args) : processFn(input, options).apply(this, args); + }; + } else { + ret = Object.create(Object.getPrototypeOf(input)); + } + for (const key2 in input) { + const property = input[key2]; + ret[key2] = typeof property === "function" && filter(key2) ? processFn(property, options) : property; + } + return ret; + }; + } +}); + +// node_modules/.pnpm/ignore@5.2.4/node_modules/ignore/index.js +var require_ignore = __commonJS({ + "node_modules/.pnpm/ignore@5.2.4/node_modules/ignore/index.js"(exports2, module2) { + init_polyfill_buffer(); + function makeArray(subject) { + return Array.isArray(subject) ? subject : [subject]; + } + var EMPTY = ""; + var SPACE = " "; + var ESCAPE = "\\"; + var REGEX_TEST_BLANK_LINE = /^\s+$/; + var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/; + var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/; + var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/; + var REGEX_SPLITALL_CRLF = /\r?\n/g; + var REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/; + var SLASH = "/"; + var TMP_KEY_IGNORE = "node-ignore"; + if (typeof Symbol !== "undefined") { + TMP_KEY_IGNORE = Symbol.for("node-ignore"); + } + var KEY_IGNORE = TMP_KEY_IGNORE; + var define2 = (object, key2, value) => Object.defineProperty(object, key2, { value }); + var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g; + var RETURN_FALSE = () => false; + var sanitizeRange = (range) => range.replace( + REGEX_REGEXP_RANGE, + (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY + ); + var cleanRangeBackSlash = (slashes) => { + const { length } = slashes; + return slashes.slice(0, length - length % 2); + }; + var REPLACERS = [ + // > Trailing spaces are ignored unless they are quoted with backslash ("\") + [ + // (a\ ) -> (a ) + // (a ) -> (a) + // (a \ ) -> (a ) + /\\?\s+$/, + (match) => match.indexOf("\\") === 0 ? SPACE : EMPTY + ], + // replace (\ ) with ' ' + [ + /\\\s/g, + () => SPACE + ], + // Escape metacharacters + // which is written down by users but means special for regular expressions. + // > There are 12 characters with special meanings: + // > - the backslash \, + // > - the caret ^, + // > - the dollar sign $, + // > - the period or dot ., + // > - the vertical bar or pipe symbol |, + // > - the question mark ?, + // > - the asterisk or star *, + // > - the plus sign +, + // > - the opening parenthesis (, + // > - the closing parenthesis ), + // > - and the opening square bracket [, + // > - the opening curly brace {, + // > These special characters are often called "metacharacters". + [ + /[\\$.|*+(){^]/g, + (match) => `\\${match}` + ], + [ + // > a question mark (?) matches a single character + /(?!\\)\?/g, + () => "[^/]" + ], + // leading slash + [ + // > A leading slash matches the beginning of the pathname. + // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c". + // A leading slash matches the beginning of the pathname + /^\//, + () => "^" + ], + // replace special metacharacter slash after the leading slash + [ + /\//g, + () => "\\/" + ], + [ + // > A leading "**" followed by a slash means match in all directories. + // > For example, "**/foo" matches file or directory "foo" anywhere, + // > the same as pattern "foo". + // > "**/foo/bar" matches file or directory "bar" anywhere that is directly + // > under directory "foo". + // Notice that the '*'s have been replaced as '\\*' + /^\^*\\\*\\\*\\\//, + // '**/foo' <-> 'foo' + () => "^(?:.*\\/)?" + ], + // starting + [ + // there will be no leading '/' + // (which has been replaced by section "leading slash") + // If starts with '**', adding a '^' to the regular expression also works + /^(?=[^^])/, + function startingReplacer() { + return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^"; + } + ], + // two globstars + [ + // Use lookahead assertions so that we could match more than one `'/**'` + /\\\/\\\*\\\*(?=\\\/|$)/g, + // Zero, one or several directories + // should not use '*', or it will be replaced by the next replacer + // Check if it is not the last `'/**'` + (_, index2, str) => index2 + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+" + ], + // normal intermediate wildcards + [ + // Never replace escaped '*' + // ignore rule '\*' will match the path '*' + // 'abc.*/' -> go + // 'abc.*' -> skip this rule, + // coz trailing single wildcard will be handed by [trailing wildcard] + /(^|[^\\]+)(\\\*)+(?=.+)/g, + // '*.js' matches '.js' + // '*.js' doesn't match 'abc' + (_, p1, p2) => { + const unescaped = p2.replace(/\\\*/g, "[^\\/]*"); + return p1 + unescaped; + } + ], + [ + // unescape, revert step 3 except for back slash + // For example, if a user escape a '\\*', + // after step 3, the result will be '\\\\\\*' + /\\\\\\(?=[$.|*+(){^])/g, + () => ESCAPE + ], + [ + // '\\\\' -> '\\' + /\\\\/g, + () => ESCAPE + ], + [ + // > The range notation, e.g. [a-zA-Z], + // > can be used to match one of the characters in a range. + // `\` is escaped by step 3 + /(\\)?\[([^\]/]*?)(\\*)($|\])/g, + (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]" + ], + // ending + [ + // 'js' will not match 'js.' + // 'ab' will not match 'abc' + /(?:[^*])$/, + // WTF! + // https://git-scm.com/docs/gitignore + // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1) + // which re-fixes #24, #38 + // > If there is a separator at the end of the pattern then the pattern + // > will only match directories, otherwise the pattern can match both + // > files and directories. + // 'js*' will not match 'a.js' + // 'js/' will not match 'a.js' + // 'js' will match 'a.js' and 'a.js/' + (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)` + ], + // trailing wildcard + [ + /(\^|\\\/)?\\\*$/, + (_, p1) => { + const prefix = p1 ? `${p1}[^/]+` : "[^/]*"; + return `${prefix}(?=$|\\/$)`; + } + ] + ]; + var regexCache = /* @__PURE__ */ Object.create(null); + var makeRegex = (pattern, ignoreCase) => { + let source = regexCache[pattern]; + if (!source) { + source = REPLACERS.reduce( + (prev, current) => prev.replace(current[0], current[1].bind(pattern)), + pattern + ); + regexCache[pattern] = source; + } + return ignoreCase ? new RegExp(source, "i") : new RegExp(source); + }; + var isString = (subject) => typeof subject === "string"; + var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0; + var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF); + var IgnoreRule = class { + constructor(origin, pattern, negative, regex2) { + this.origin = origin; + this.pattern = pattern; + this.negative = negative; + this.regex = regex2; + } + }; + var createRule = (pattern, ignoreCase) => { + const origin = pattern; + let negative = false; + if (pattern.indexOf("!") === 0) { + negative = true; + pattern = pattern.substr(1); + } + pattern = pattern.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#"); + const regex2 = makeRegex(pattern, ignoreCase); + return new IgnoreRule( + origin, + pattern, + negative, + regex2 + ); + }; + var throwError = (message, Ctor) => { + throw new Ctor(message); + }; + var checkPath = (path2, originalPath, doThrow) => { + if (!isString(path2)) { + return doThrow( + `path must be a string, but got \`${originalPath}\``, + TypeError + ); + } + if (!path2) { + return doThrow(`path must not be empty`, TypeError); + } + if (checkPath.isNotRelative(path2)) { + const r = "`path.relative()`d"; + return doThrow( + `path should be a ${r} string, but got "${originalPath}"`, + RangeError + ); + } + return true; + }; + var isNotRelative = (path2) => REGEX_TEST_INVALID_PATH.test(path2); + checkPath.isNotRelative = isNotRelative; + checkPath.convert = (p) => p; + var Ignore = class { + constructor({ + ignorecase = true, + ignoreCase = ignorecase, + allowRelativePaths = false + } = {}) { + define2(this, KEY_IGNORE, true); + this._rules = []; + this._ignoreCase = ignoreCase; + this._allowRelativePaths = allowRelativePaths; + this._initCache(); + } + _initCache() { + this._ignoreCache = /* @__PURE__ */ Object.create(null); + this._testCache = /* @__PURE__ */ Object.create(null); + } + _addPattern(pattern) { + if (pattern && pattern[KEY_IGNORE]) { + this._rules = this._rules.concat(pattern._rules); + this._added = true; + return; + } + if (checkPattern(pattern)) { + const rule = createRule(pattern, this._ignoreCase); + this._added = true; + this._rules.push(rule); + } + } + // @param {Array | string | Ignore} pattern + add(pattern) { + this._added = false; + makeArray( + isString(pattern) ? splitPattern(pattern) : pattern + ).forEach(this._addPattern, this); + if (this._added) { + this._initCache(); + } + return this; + } + // legacy + addPattern(pattern) { + return this.add(pattern); + } + // | ignored : unignored + // negative | 0:0 | 0:1 | 1:0 | 1:1 + // -------- | ------- | ------- | ------- | -------- + // 0 | TEST | TEST | SKIP | X + // 1 | TESTIF | SKIP | TEST | X + // - SKIP: always skip + // - TEST: always test + // - TESTIF: only test if checkUnignored + // - X: that never happen + // @param {boolean} whether should check if the path is unignored, + // setting `checkUnignored` to `false` could reduce additional + // path matching. + // @returns {TestResult} true if a file is ignored + _testOne(path2, checkUnignored) { + let ignored = false; + let unignored = false; + this._rules.forEach((rule) => { + const { negative } = rule; + if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) { + return; + } + const matched = rule.regex.test(path2); + if (matched) { + ignored = !negative; + unignored = negative; + } + }); + return { + ignored, + unignored + }; + } + // @returns {TestResult} + _test(originalPath, cache, checkUnignored, slices) { + const path2 = originalPath && checkPath.convert(originalPath); + checkPath( + path2, + originalPath, + this._allowRelativePaths ? RETURN_FALSE : throwError + ); + return this._t(path2, cache, checkUnignored, slices); + } + _t(path2, cache, checkUnignored, slices) { + if (path2 in cache) { + return cache[path2]; + } + if (!slices) { + slices = path2.split(SLASH); + } + slices.pop(); + if (!slices.length) { + return cache[path2] = this._testOne(path2, checkUnignored); + } + const parent = this._t( + slices.join(SLASH) + SLASH, + cache, + checkUnignored, + slices + ); + return cache[path2] = parent.ignored ? parent : this._testOne(path2, checkUnignored); + } + ignores(path2) { + return this._test(path2, this._ignoreCache, false).ignored; + } + createFilter() { + return (path2) => !this.ignores(path2); + } + filter(paths) { + return makeArray(paths).filter(this.createFilter()); + } + // @returns {TestResult} + test(path2) { + return this._test(path2, this._testCache, true); + } + }; + var factory = (options) => new Ignore(options); + var isPathValid = (path2) => checkPath(path2 && checkPath.convert(path2), path2, RETURN_FALSE); + factory.isPathValid = isPathValid; + factory.default = factory; + module2.exports = factory; + if ( + // Detect `process` so that it can run in browsers. + typeof process !== "undefined" && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === "win32") + ) { + const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/"); + checkPath.convert = makePosix; + const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i; + checkPath.isNotRelative = (path2) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path2) || isNotRelative(path2); + } + } +}); + +// node_modules/.pnpm/clean-git-ref@2.0.1/node_modules/clean-git-ref/lib/index.js +var require_lib2 = __commonJS({ + "node_modules/.pnpm/clean-git-ref@2.0.1/node_modules/clean-git-ref/lib/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + function escapeRegExp(string) { + return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); + } + function replaceAll(str, search, replacement) { + search = search instanceof RegExp ? search : new RegExp(escapeRegExp(search), "g"); + return str.replace(search, replacement); + } + var CleanGitRef = { + clean: function clean(value) { + if (typeof value !== "string") { + throw new Error("Expected a string, received: " + value); + } + value = replaceAll(value, "./", "/"); + value = replaceAll(value, "..", "."); + value = replaceAll(value, " ", "-"); + value = replaceAll(value, /^[~^:?*\\\-]/g, ""); + value = replaceAll(value, /[~^:?*\\]/g, "-"); + value = replaceAll(value, /[~^:?*\\\-]$/g, ""); + value = replaceAll(value, "@{", "-"); + value = replaceAll(value, /\.$/g, ""); + value = replaceAll(value, /\/$/g, ""); + value = replaceAll(value, /\.lock$/g, ""); + return value; + } + }; + module2.exports = CleanGitRef; + } +}); + +// node_modules/.pnpm/diff3@0.0.3/node_modules/diff3/onp.js +var require_onp = __commonJS({ + "node_modules/.pnpm/diff3@0.0.3/node_modules/diff3/onp.js"(exports2, module2) { + init_polyfill_buffer(); + module2.exports = function(a_, b_) { + var a = a_, b = b_, m = a.length, n = b.length, reverse = false, ed = null, offset = m + 1, path2 = [], pathposi = [], ses = [], lcs = "", SES_DELETE = -1, SES_COMMON = 0, SES_ADD = 1; + var tmp1, tmp2; + var init3 = function() { + if (m >= n) { + tmp1 = a; + tmp2 = m; + a = b; + b = tmp1; + m = n; + n = tmp2; + reverse = true; + offset = m + 1; + } + }; + var P = function(x, y, k) { + return { + "x": x, + "y": y, + "k": k + }; + }; + var seselem = function(elem, t) { + return { + "elem": elem, + "t": t + }; + }; + var snake = function(k, p, pp) { + var r, x, y; + if (p > pp) { + r = path2[k - 1 + offset]; + } else { + r = path2[k + 1 + offset]; + } + y = Math.max(p, pp); + x = y - k; + while (x < m && y < n && a[x] === b[y]) { + ++x; + ++y; + } + path2[k + offset] = pathposi.length; + pathposi[pathposi.length] = new P(x, y, r); + return y; + }; + var recordseq = function(epc) { + var x_idx, y_idx, px_idx, py_idx, i; + x_idx = y_idx = 1; + px_idx = py_idx = 0; + for (i = epc.length - 1; i >= 0; --i) { + while (px_idx < epc[i].x || py_idx < epc[i].y) { + if (epc[i].y - epc[i].x > py_idx - px_idx) { + if (reverse) { + ses[ses.length] = new seselem(b[py_idx], SES_DELETE); + } else { + ses[ses.length] = new seselem(b[py_idx], SES_ADD); + } + ++y_idx; + ++py_idx; + } else if (epc[i].y - epc[i].x < py_idx - px_idx) { + if (reverse) { + ses[ses.length] = new seselem(a[px_idx], SES_ADD); + } else { + ses[ses.length] = new seselem(a[px_idx], SES_DELETE); + } + ++x_idx; + ++px_idx; + } else { + ses[ses.length] = new seselem(a[px_idx], SES_COMMON); + lcs += a[px_idx]; + ++x_idx; + ++y_idx; + ++px_idx; + ++py_idx; + } + } + } + }; + init3(); + return { + SES_DELETE: -1, + SES_COMMON: 0, + SES_ADD: 1, + editdistance: function() { + return ed; + }, + getlcs: function() { + return lcs; + }, + getses: function() { + return ses; + }, + compose: function() { + var delta, size, fp, p, r, epc, i, k; + delta = n - m; + size = m + n + 3; + fp = {}; + for (i = 0; i < size; ++i) { + fp[i] = -1; + path2[i] = -1; + } + p = -1; + do { + ++p; + for (k = -p; k <= delta - 1; ++k) { + fp[k + offset] = snake(k, fp[k - 1 + offset] + 1, fp[k + 1 + offset]); + } + for (k = delta + p; k >= delta + 1; --k) { + fp[k + offset] = snake(k, fp[k - 1 + offset] + 1, fp[k + 1 + offset]); + } + fp[delta + offset] = snake(delta, fp[delta - 1 + offset] + 1, fp[delta + 1 + offset]); + } while (fp[delta + offset] !== n); + ed = delta + 2 * p; + r = path2[delta + offset]; + epc = []; + while (r !== -1) { + epc[epc.length] = new P(pathposi[r].x, pathposi[r].y, null); + r = pathposi[r].k; + } + recordseq(epc); + } + }; + }; + } +}); + +// node_modules/.pnpm/diff3@0.0.3/node_modules/diff3/diff3.js +var require_diff3 = __commonJS({ + "node_modules/.pnpm/diff3@0.0.3/node_modules/diff3/diff3.js"(exports2, module2) { + init_polyfill_buffer(); + var onp = require_onp(); + function longestCommonSubsequence(file1, file2) { + var diff2 = new onp(file1, file2); + diff2.compose(); + var ses = diff2.getses(); + var root2; + var prev; + var file1RevIdx = file1.length - 1, file2RevIdx = file2.length - 1; + for (var i = ses.length - 1; i >= 0; --i) { + if (ses[i].t === diff2.SES_COMMON) { + if (prev) { + prev.chain = { + file1index: file1RevIdx, + file2index: file2RevIdx, + chain: null + }; + prev = prev.chain; + } else { + root2 = { + file1index: file1RevIdx, + file2index: file2RevIdx, + chain: null + }; + prev = root2; + } + file1RevIdx--; + file2RevIdx--; + } else if (ses[i].t === diff2.SES_DELETE) { + file1RevIdx--; + } else if (ses[i].t === diff2.SES_ADD) { + file2RevIdx--; + } + } + var tail = { + file1index: -1, + file2index: -1, + chain: null + }; + if (!prev) { + return tail; + } + prev.chain = tail; + return root2; + } + function diffIndices(file1, file2) { + var result = []; + var tail1 = file1.length; + var tail2 = file2.length; + for (var candidate = longestCommonSubsequence(file1, file2); candidate !== null; candidate = candidate.chain) { + var mismatchLength1 = tail1 - candidate.file1index - 1; + var mismatchLength2 = tail2 - candidate.file2index - 1; + tail1 = candidate.file1index; + tail2 = candidate.file2index; + if (mismatchLength1 || mismatchLength2) { + result.push({ + file1: [tail1 + 1, mismatchLength1], + file2: [tail2 + 1, mismatchLength2] + }); + } + } + result.reverse(); + return result; + } + function diff3MergeIndices(a, o, b) { + var i; + var m1 = diffIndices(o, a); + var m2 = diffIndices(o, b); + var hunks = []; + function addHunk(h, side2) { + hunks.push([h.file1[0], side2, h.file1[1], h.file2[0], h.file2[1]]); + } + for (i = 0; i < m1.length; i++) { + addHunk(m1[i], 0); + } + for (i = 0; i < m2.length; i++) { + addHunk(m2[i], 2); + } + hunks.sort(function(x, y) { + return x[0] - y[0]; + }); + var result = []; + var commonOffset = 0; + function copyCommon(targetOffset) { + if (targetOffset > commonOffset) { + result.push([1, commonOffset, targetOffset - commonOffset]); + commonOffset = targetOffset; + } + } + for (var hunkIndex = 0; hunkIndex < hunks.length; hunkIndex++) { + var firstHunkIndex = hunkIndex; + var hunk = hunks[hunkIndex]; + var regionLhs = hunk[0]; + var regionRhs = regionLhs + hunk[2]; + while (hunkIndex < hunks.length - 1) { + var maybeOverlapping = hunks[hunkIndex + 1]; + var maybeLhs = maybeOverlapping[0]; + if (maybeLhs > regionRhs) + break; + regionRhs = Math.max(regionRhs, maybeLhs + maybeOverlapping[2]); + hunkIndex++; + } + copyCommon(regionLhs); + if (firstHunkIndex == hunkIndex) { + if (hunk[4] > 0) { + result.push([hunk[1], hunk[3], hunk[4]]); + } + } else { + var regions = { + 0: [a.length, -1, o.length, -1], + 2: [b.length, -1, o.length, -1] + }; + for (i = firstHunkIndex; i <= hunkIndex; i++) { + hunk = hunks[i]; + var side = hunk[1]; + var r = regions[side]; + var oLhs = hunk[0]; + var oRhs = oLhs + hunk[2]; + var abLhs = hunk[3]; + var abRhs = abLhs + hunk[4]; + r[0] = Math.min(abLhs, r[0]); + r[1] = Math.max(abRhs, r[1]); + r[2] = Math.min(oLhs, r[2]); + r[3] = Math.max(oRhs, r[3]); + } + var aLhs = regions[0][0] + (regionLhs - regions[0][2]); + var aRhs = regions[0][1] + (regionRhs - regions[0][3]); + var bLhs = regions[2][0] + (regionLhs - regions[2][2]); + var bRhs = regions[2][1] + (regionRhs - regions[2][3]); + result.push([ + -1, + aLhs, + aRhs - aLhs, + regionLhs, + regionRhs - regionLhs, + bLhs, + bRhs - bLhs + ]); + } + commonOffset = regionRhs; + } + copyCommon(o.length); + return result; + } + function diff3Merge2(a, o, b) { + var result = []; + var files = [a, o, b]; + var indices = diff3MergeIndices(a, o, b); + var okLines = []; + function flushOk() { + if (okLines.length) { + result.push({ + ok: okLines + }); + } + okLines = []; + } + function pushOk(xs) { + for (var j = 0; j < xs.length; j++) { + okLines.push(xs[j]); + } + } + function isTrueConflict(rec) { + if (rec[2] != rec[6]) + return true; + var aoff = rec[1]; + var boff = rec[5]; + for (var j = 0; j < rec[2]; j++) { + if (a[j + aoff] != b[j + boff]) + return true; + } + return false; + } + for (var i = 0; i < indices.length; i++) { + var x = indices[i]; + var side = x[0]; + if (side == -1) { + if (!isTrueConflict(x)) { + pushOk(files[0].slice(x[1], x[1] + x[2])); + } else { + flushOk(); + result.push({ + conflict: { + a: a.slice(x[1], x[1] + x[2]), + aIndex: x[1], + o: o.slice(x[3], x[3] + x[4]), + oIndex: x[3], + b: b.slice(x[5], x[5] + x[6]), + bIndex: x[5] + } + }); + } + } else { + pushOk(files[side].slice(x[1], x[1] + x[2])); + } + } + flushOk(); + return result; + } + module2.exports = diff3Merge2; + } +}); + +// node_modules/.pnpm/ms@2.1.2/node_modules/ms/index.js +var require_ms = __commonJS({ + "node_modules/.pnpm/ms@2.1.2/node_modules/ms/index.js"(exports2, module2) { + init_polyfill_buffer(); + var s = 1e3; + var m = s * 60; + var h = m * 60; + var d = h * 24; + var w = d * 7; + var y = d * 365.25; + module2.exports = function(val, options) { + options = options || {}; + var type = typeof val; + if (type === "string" && val.length > 0) { + return parse2(val); + } else if (type === "number" && isFinite(val)) { + return options.long ? fmtLong(val) : fmtShort(val); + } + throw new Error( + "val is not a non-empty string or a valid number. val=" + JSON.stringify(val) + ); + }; + function parse2(str) { + str = String(str); + if (str.length > 100) { + return; + } + var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec( + str + ); + if (!match) { + return; + } + var n = parseFloat(match[1]); + var type = (match[2] || "ms").toLowerCase(); + switch (type) { + case "years": + case "year": + case "yrs": + case "yr": + case "y": + return n * y; + case "weeks": + case "week": + case "w": + return n * w; + case "days": + case "day": + case "d": + return n * d; + case "hours": + case "hour": + case "hrs": + case "hr": + case "h": + return n * h; + case "minutes": + case "minute": + case "mins": + case "min": + case "m": + return n * m; + case "seconds": + case "second": + case "secs": + case "sec": + case "s": + return n * s; + case "milliseconds": + case "millisecond": + case "msecs": + case "msec": + case "ms": + return n; + default: + return void 0; + } + } + function fmtShort(ms) { + var msAbs = Math.abs(ms); + if (msAbs >= d) { + return Math.round(ms / d) + "d"; + } + if (msAbs >= h) { + return Math.round(ms / h) + "h"; + } + if (msAbs >= m) { + return Math.round(ms / m) + "m"; + } + if (msAbs >= s) { + return Math.round(ms / s) + "s"; + } + return ms + "ms"; + } + function fmtLong(ms) { + var msAbs = Math.abs(ms); + if (msAbs >= d) { + return plural(ms, msAbs, d, "day"); + } + if (msAbs >= h) { + return plural(ms, msAbs, h, "hour"); + } + if (msAbs >= m) { + return plural(ms, msAbs, m, "minute"); + } + if (msAbs >= s) { + return plural(ms, msAbs, s, "second"); + } + return ms + " ms"; + } + function plural(ms, msAbs, n, name) { + var isPlural = msAbs >= n * 1.5; + return Math.round(ms / n) + " " + name + (isPlural ? "s" : ""); + } + } +}); + +// node_modules/.pnpm/debug@4.3.4_supports-color@9.4.0/node_modules/debug/src/common.js +var require_common2 = __commonJS({ + "node_modules/.pnpm/debug@4.3.4_supports-color@9.4.0/node_modules/debug/src/common.js"(exports2, module2) { + init_polyfill_buffer(); + function setup(env) { + createDebug.debug = createDebug; + createDebug.default = createDebug; + createDebug.coerce = coerce; + createDebug.disable = disable; + createDebug.enable = enable; + createDebug.enabled = enabled; + createDebug.humanize = require_ms(); + createDebug.destroy = destroy; + Object.keys(env).forEach((key2) => { + createDebug[key2] = env[key2]; + }); + createDebug.names = []; + createDebug.skips = []; + createDebug.formatters = {}; + function selectColor(namespace) { + let hash2 = 0; + for (let i = 0; i < namespace.length; i++) { + hash2 = (hash2 << 5) - hash2 + namespace.charCodeAt(i); + hash2 |= 0; + } + return createDebug.colors[Math.abs(hash2) % createDebug.colors.length]; + } + createDebug.selectColor = selectColor; + function createDebug(namespace) { + let prevTime; + let enableOverride = null; + let namespacesCache; + let enabledCache; + function debug3(...args) { + if (!debug3.enabled) { + return; + } + const self2 = debug3; + const curr = Number(/* @__PURE__ */ new Date()); + const ms = curr - (prevTime || curr); + self2.diff = ms; + self2.prev = prevTime; + self2.curr = curr; + prevTime = curr; + args[0] = createDebug.coerce(args[0]); + if (typeof args[0] !== "string") { + args.unshift("%O"); + } + let index2 = 0; + args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => { + if (match === "%%") { + return "%"; + } + index2++; + const formatter = createDebug.formatters[format]; + if (typeof formatter === "function") { + const val = args[index2]; + match = formatter.call(self2, val); + args.splice(index2, 1); + index2--; + } + return match; + }); + createDebug.formatArgs.call(self2, args); + const logFn = self2.log || createDebug.log; + logFn.apply(self2, args); + } + debug3.namespace = namespace; + debug3.useColors = createDebug.useColors(); + debug3.color = createDebug.selectColor(namespace); + debug3.extend = extend; + debug3.destroy = createDebug.destroy; + Object.defineProperty(debug3, "enabled", { + enumerable: true, + configurable: false, + get: () => { + if (enableOverride !== null) { + return enableOverride; + } + if (namespacesCache !== createDebug.namespaces) { + namespacesCache = createDebug.namespaces; + enabledCache = createDebug.enabled(namespace); + } + return enabledCache; + }, + set: (v) => { + enableOverride = v; + } + }); + if (typeof createDebug.init === "function") { + createDebug.init(debug3); + } + return debug3; + } + function extend(namespace, delimiter) { + const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace); + newDebug.log = this.log; + return newDebug; + } + function enable(namespaces) { + createDebug.save(namespaces); + createDebug.namespaces = namespaces; + createDebug.names = []; + createDebug.skips = []; + let i; + const split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/); + const len = split.length; + for (i = 0; i < len; i++) { + if (!split[i]) { + continue; + } + namespaces = split[i].replace(/\*/g, ".*?"); + if (namespaces[0] === "-") { + createDebug.skips.push(new RegExp("^" + namespaces.slice(1) + "$")); + } else { + createDebug.names.push(new RegExp("^" + namespaces + "$")); + } + } + } + function disable() { + const namespaces = [ + ...createDebug.names.map(toNamespace), + ...createDebug.skips.map(toNamespace).map((namespace) => "-" + namespace) + ].join(","); + createDebug.enable(""); + return namespaces; + } + function enabled(name) { + if (name[name.length - 1] === "*") { + return true; + } + let i; + let len; + for (i = 0, len = createDebug.skips.length; i < len; i++) { + if (createDebug.skips[i].test(name)) { + return false; + } + } + for (i = 0, len = createDebug.names.length; i < len; i++) { + if (createDebug.names[i].test(name)) { + return true; + } + } + return false; + } + function toNamespace(regexp) { + return regexp.toString().substring(2, regexp.toString().length - 2).replace(/\.\*\?$/, "*"); + } + function coerce(val) { + if (val instanceof Error) { + return val.stack || val.message; + } + return val; + } + function destroy() { + console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."); + } + createDebug.enable(createDebug.load()); + return createDebug; + } + module2.exports = setup; + } +}); + +// node_modules/.pnpm/debug@4.3.4_supports-color@9.4.0/node_modules/debug/src/browser.js +var require_browser = __commonJS({ + "node_modules/.pnpm/debug@4.3.4_supports-color@9.4.0/node_modules/debug/src/browser.js"(exports2, module2) { + init_polyfill_buffer(); + exports2.formatArgs = formatArgs; + exports2.save = save; + exports2.load = load; + exports2.useColors = useColors; + exports2.storage = localstorage(); + exports2.destroy = (() => { + let warned = false; + return () => { + if (!warned) { + warned = true; + console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."); + } + }; + })(); + exports2.colors = [ + "#0000CC", + "#0000FF", + "#0033CC", + "#0033FF", + "#0066CC", + "#0066FF", + "#0099CC", + "#0099FF", + "#00CC00", + "#00CC33", + "#00CC66", + "#00CC99", + "#00CCCC", + "#00CCFF", + "#3300CC", + "#3300FF", + "#3333CC", + "#3333FF", + "#3366CC", + "#3366FF", + "#3399CC", + "#3399FF", + "#33CC00", + "#33CC33", + "#33CC66", + "#33CC99", + "#33CCCC", + "#33CCFF", + "#6600CC", + "#6600FF", + "#6633CC", + "#6633FF", + "#66CC00", + "#66CC33", + "#9900CC", + "#9900FF", + "#9933CC", + "#9933FF", + "#99CC00", + "#99CC33", + "#CC0000", + "#CC0033", + "#CC0066", + "#CC0099", + "#CC00CC", + "#CC00FF", + "#CC3300", + "#CC3333", + "#CC3366", + "#CC3399", + "#CC33CC", + "#CC33FF", + "#CC6600", + "#CC6633", + "#CC9900", + "#CC9933", + "#CCCC00", + "#CCCC33", + "#FF0000", + "#FF0033", + "#FF0066", + "#FF0099", + "#FF00CC", + "#FF00FF", + "#FF3300", + "#FF3333", + "#FF3366", + "#FF3399", + "#FF33CC", + "#FF33FF", + "#FF6600", + "#FF6633", + "#FF9900", + "#FF9933", + "#FFCC00", + "#FFCC33" + ]; + function useColors() { + if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) { + return true; + } + if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) { + return false; + } + return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773 + typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31? + // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages + typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker + typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/); + } + function formatArgs(args) { + args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module2.exports.humanize(this.diff); + if (!this.useColors) { + return; + } + const c = "color: " + this.color; + args.splice(1, 0, c, "color: inherit"); + let index2 = 0; + let lastC = 0; + args[0].replace(/%[a-zA-Z%]/g, (match) => { + if (match === "%%") { + return; + } + index2++; + if (match === "%c") { + lastC = index2; + } + }); + args.splice(lastC, 0, c); + } + exports2.log = console.debug || console.log || (() => { + }); + function save(namespaces) { + try { + if (namespaces) { + exports2.storage.setItem("debug", namespaces); + } else { + exports2.storage.removeItem("debug"); + } + } catch (error) { + } + } + function load() { + let r; + try { + r = exports2.storage.getItem("debug"); + } catch (error) { + } + if (!r && typeof process !== "undefined" && "env" in process) { + r = process.env.DEBUG; + } + return r; + } + function localstorage() { + try { + return localStorage; + } catch (error) { + } + } + module2.exports = require_common2()(exports2); + var { formatters } = module2.exports; + formatters.j = function(v) { + try { + return JSON.stringify(v); + } catch (error) { + return "[UnexpectedJSONParseError]: " + error.message; + } + }; + } +}); + +// node_modules/.pnpm/@kwsites+file-exists@1.1.1_supports-color@9.4.0/node_modules/@kwsites/file-exists/dist/src/index.js +var require_src = __commonJS({ + "node_modules/.pnpm/@kwsites+file-exists@1.1.1_supports-color@9.4.0/node_modules/@kwsites/file-exists/dist/src/index.js"(exports2) { + "use strict"; + init_polyfill_buffer(); + var __importDefault = exports2 && exports2.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + var fs_1 = require("fs"); + var debug_1 = __importDefault(require_browser()); + var log2 = debug_1.default("@kwsites/file-exists"); + function check(path2, isFile, isDirectory) { + log2(`checking %s`, path2); + try { + const stat = fs_1.statSync(path2); + if (stat.isFile() && isFile) { + log2(`[OK] path represents a file`); + return true; + } + if (stat.isDirectory() && isDirectory) { + log2(`[OK] path represents a directory`); + return true; + } + log2(`[FAIL] path represents something other than a file or directory`); + return false; + } catch (e) { + if (e.code === "ENOENT") { + log2(`[FAIL] path is not accessible: %o`, e); + return false; + } + log2(`[FATAL] %o`, e); + throw e; + } + } + function exists2(path2, type = exports2.READABLE) { + return check(path2, (type & exports2.FILE) > 0, (type & exports2.FOLDER) > 0); + } + exports2.exists = exists2; + exports2.FILE = 1; + exports2.FOLDER = 2; + exports2.READABLE = exports2.FILE + exports2.FOLDER; + } +}); + +// node_modules/.pnpm/@kwsites+file-exists@1.1.1_supports-color@9.4.0/node_modules/@kwsites/file-exists/dist/index.js +var require_dist = __commonJS({ + "node_modules/.pnpm/@kwsites+file-exists@1.1.1_supports-color@9.4.0/node_modules/@kwsites/file-exists/dist/index.js"(exports2) { + "use strict"; + init_polyfill_buffer(); + function __export3(m) { + for (var p in m) + if (!exports2.hasOwnProperty(p)) + exports2[p] = m[p]; + } + Object.defineProperty(exports2, "__esModule", { value: true }); + __export3(require_src()); + } +}); + +// node_modules/.pnpm/@kwsites+promise-deferred@1.1.1/node_modules/@kwsites/promise-deferred/dist/index.js +var require_dist2 = __commonJS({ + "node_modules/.pnpm/@kwsites+promise-deferred@1.1.1/node_modules/@kwsites/promise-deferred/dist/index.js"(exports2) { + "use strict"; + init_polyfill_buffer(); + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.createDeferred = exports2.deferred = void 0; + function deferred2() { + let done; + let fail; + let status2 = "pending"; + const promise2 = new Promise((_done, _fail) => { + done = _done; + fail = _fail; + }); + return { + promise: promise2, + done(result) { + if (status2 === "pending") { + status2 = "resolved"; + done(result); + } + }, + fail(error) { + if (status2 === "pending") { + status2 = "rejected"; + fail(error); + } + }, + get fulfilled() { + return status2 !== "pending"; + }, + get status() { + return status2; + } + }; + } + exports2.deferred = deferred2; + exports2.createDeferred = deferred2; + exports2.default = deferred2; + } +}); + +// node_modules/.pnpm/color-name@1.1.4/node_modules/color-name/index.js +var require_color_name = __commonJS({ + "node_modules/.pnpm/color-name@1.1.4/node_modules/color-name/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + module2.exports = { + "aliceblue": [240, 248, 255], + "antiquewhite": [250, 235, 215], + "aqua": [0, 255, 255], + "aquamarine": [127, 255, 212], + "azure": [240, 255, 255], + "beige": [245, 245, 220], + "bisque": [255, 228, 196], + "black": [0, 0, 0], + "blanchedalmond": [255, 235, 205], + "blue": [0, 0, 255], + "blueviolet": [138, 43, 226], + "brown": [165, 42, 42], + "burlywood": [222, 184, 135], + "cadetblue": [95, 158, 160], + "chartreuse": [127, 255, 0], + "chocolate": [210, 105, 30], + "coral": [255, 127, 80], + "cornflowerblue": [100, 149, 237], + "cornsilk": [255, 248, 220], + "crimson": [220, 20, 60], + "cyan": [0, 255, 255], + "darkblue": [0, 0, 139], + "darkcyan": [0, 139, 139], + "darkgoldenrod": [184, 134, 11], + "darkgray": [169, 169, 169], + "darkgreen": [0, 100, 0], + "darkgrey": [169, 169, 169], + "darkkhaki": [189, 183, 107], + "darkmagenta": [139, 0, 139], + "darkolivegreen": [85, 107, 47], + "darkorange": [255, 140, 0], + "darkorchid": [153, 50, 204], + "darkred": [139, 0, 0], + "darksalmon": [233, 150, 122], + "darkseagreen": [143, 188, 143], + "darkslateblue": [72, 61, 139], + "darkslategray": [47, 79, 79], + "darkslategrey": [47, 79, 79], + "darkturquoise": [0, 206, 209], + "darkviolet": [148, 0, 211], + "deeppink": [255, 20, 147], + "deepskyblue": [0, 191, 255], + "dimgray": [105, 105, 105], + "dimgrey": [105, 105, 105], + "dodgerblue": [30, 144, 255], + "firebrick": [178, 34, 34], + "floralwhite": [255, 250, 240], + "forestgreen": [34, 139, 34], + "fuchsia": [255, 0, 255], + "gainsboro": [220, 220, 220], + "ghostwhite": [248, 248, 255], + "gold": [255, 215, 0], + "goldenrod": [218, 165, 32], + "gray": [128, 128, 128], + "green": [0, 128, 0], + "greenyellow": [173, 255, 47], + "grey": [128, 128, 128], + "honeydew": [240, 255, 240], + "hotpink": [255, 105, 180], + "indianred": [205, 92, 92], + "indigo": [75, 0, 130], + "ivory": [255, 255, 240], + "khaki": [240, 230, 140], + "lavender": [230, 230, 250], + "lavenderblush": [255, 240, 245], + "lawngreen": [124, 252, 0], + "lemonchiffon": [255, 250, 205], + "lightblue": [173, 216, 230], + "lightcoral": [240, 128, 128], + "lightcyan": [224, 255, 255], + "lightgoldenrodyellow": [250, 250, 210], + "lightgray": [211, 211, 211], + "lightgreen": [144, 238, 144], + "lightgrey": [211, 211, 211], + "lightpink": [255, 182, 193], + "lightsalmon": [255, 160, 122], + "lightseagreen": [32, 178, 170], + "lightskyblue": [135, 206, 250], + "lightslategray": [119, 136, 153], + "lightslategrey": [119, 136, 153], + "lightsteelblue": [176, 196, 222], + "lightyellow": [255, 255, 224], + "lime": [0, 255, 0], + "limegreen": [50, 205, 50], + "linen": [250, 240, 230], + "magenta": [255, 0, 255], + "maroon": [128, 0, 0], + "mediumaquamarine": [102, 205, 170], + "mediumblue": [0, 0, 205], + "mediumorchid": [186, 85, 211], + "mediumpurple": [147, 112, 219], + "mediumseagreen": [60, 179, 113], + "mediumslateblue": [123, 104, 238], + "mediumspringgreen": [0, 250, 154], + "mediumturquoise": [72, 209, 204], + "mediumvioletred": [199, 21, 133], + "midnightblue": [25, 25, 112], + "mintcream": [245, 255, 250], + "mistyrose": [255, 228, 225], + "moccasin": [255, 228, 181], + "navajowhite": [255, 222, 173], + "navy": [0, 0, 128], + "oldlace": [253, 245, 230], + "olive": [128, 128, 0], + "olivedrab": [107, 142, 35], + "orange": [255, 165, 0], + "orangered": [255, 69, 0], + "orchid": [218, 112, 214], + "palegoldenrod": [238, 232, 170], + "palegreen": [152, 251, 152], + "paleturquoise": [175, 238, 238], + "palevioletred": [219, 112, 147], + "papayawhip": [255, 239, 213], + "peachpuff": [255, 218, 185], + "peru": [205, 133, 63], + "pink": [255, 192, 203], + "plum": [221, 160, 221], + "powderblue": [176, 224, 230], + "purple": [128, 0, 128], + "rebeccapurple": [102, 51, 153], + "red": [255, 0, 0], + "rosybrown": [188, 143, 143], + "royalblue": [65, 105, 225], + "saddlebrown": [139, 69, 19], + "salmon": [250, 128, 114], + "sandybrown": [244, 164, 96], + "seagreen": [46, 139, 87], + "seashell": [255, 245, 238], + "sienna": [160, 82, 45], + "silver": [192, 192, 192], + "skyblue": [135, 206, 235], + "slateblue": [106, 90, 205], + "slategray": [112, 128, 144], + "slategrey": [112, 128, 144], + "snow": [255, 250, 250], + "springgreen": [0, 255, 127], + "steelblue": [70, 130, 180], + "tan": [210, 180, 140], + "teal": [0, 128, 128], + "thistle": [216, 191, 216], + "tomato": [255, 99, 71], + "turquoise": [64, 224, 208], + "violet": [238, 130, 238], + "wheat": [245, 222, 179], + "white": [255, 255, 255], + "whitesmoke": [245, 245, 245], + "yellow": [255, 255, 0], + "yellowgreen": [154, 205, 50] + }; + } +}); + +// node_modules/.pnpm/css-unit-converter@1.1.2/node_modules/css-unit-converter/index.js +var require_css_unit_converter = __commonJS({ + "node_modules/.pnpm/css-unit-converter@1.1.2/node_modules/css-unit-converter/index.js"(exports2, module2) { + init_polyfill_buffer(); + var conversions = { + // length + "px": { + "px": 1, + "cm": 96 / 2.54, + "mm": 96 / 25.4, + "in": 96, + "pt": 96 / 72, + "pc": 16 + }, + "cm": { + "px": 2.54 / 96, + "cm": 1, + "mm": 0.1, + "in": 2.54, + "pt": 2.54 / 72, + "pc": 2.54 / 6 + }, + "mm": { + "px": 25.4 / 96, + "cm": 10, + "mm": 1, + "in": 25.4, + "pt": 25.4 / 72, + "pc": 25.4 / 6 + }, + "in": { + "px": 1 / 96, + "cm": 1 / 2.54, + "mm": 1 / 25.4, + "in": 1, + "pt": 1 / 72, + "pc": 1 / 6 + }, + "pt": { + "px": 0.75, + "cm": 72 / 2.54, + "mm": 72 / 25.4, + "in": 72, + "pt": 1, + "pc": 12 + }, + "pc": { + "px": 6 / 96, + "cm": 6 / 2.54, + "mm": 6 / 25.4, + "in": 6, + "pt": 6 / 72, + "pc": 1 + }, + // angle + "deg": { + "deg": 1, + "grad": 0.9, + "rad": 180 / Math.PI, + "turn": 360 + }, + "grad": { + "deg": 400 / 360, + "grad": 1, + "rad": 200 / Math.PI, + "turn": 400 + }, + "rad": { + "deg": Math.PI / 180, + "grad": Math.PI / 200, + "rad": 1, + "turn": Math.PI * 2 + }, + "turn": { + "deg": 1 / 360, + "grad": 1 / 400, + "rad": 0.5 / Math.PI, + "turn": 1 + }, + // time + "s": { + "s": 1, + "ms": 1 / 1e3 + }, + "ms": { + "s": 1e3, + "ms": 1 + }, + // frequency + "Hz": { + "Hz": 1, + "kHz": 1e3 + }, + "kHz": { + "Hz": 1 / 1e3, + "kHz": 1 + }, + // resolution + "dpi": { + "dpi": 1, + "dpcm": 1 / 2.54, + "dppx": 1 / 96 + }, + "dpcm": { + "dpi": 2.54, + "dpcm": 1, + "dppx": 2.54 / 96 + }, + "dppx": { + "dpi": 96, + "dpcm": 96 / 2.54, + "dppx": 1 + } + }; + module2.exports = function(value, sourceUnit, targetUnit, precision) { + if (!conversions.hasOwnProperty(targetUnit)) + throw new Error("Cannot convert to " + targetUnit); + if (!conversions[targetUnit].hasOwnProperty(sourceUnit)) + throw new Error("Cannot convert from " + sourceUnit + " to " + targetUnit); + var converted = conversions[targetUnit][sourceUnit] * value; + if (precision !== false) { + precision = Math.pow(10, parseInt(precision) || 5); + return Math.round(converted * precision) / precision; + } + return converted; + }; + } +}); + +// node_modules/.pnpm/css-color-converter@2.0.0/node_modules/css-color-converter/lib/index.js +var require_lib3 = __commonJS({ + "node_modules/.pnpm/css-color-converter@2.0.0/node_modules/css-color-converter/lib/index.js"(exports2) { + "use strict"; + init_polyfill_buffer(); + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.fromRgba = fromRgba; + exports2.fromRgb = fromRgb; + exports2.fromHsla = fromHsla; + exports2.fromHsl = fromHsl; + exports2.fromString = fromString2; + exports2["default"] = void 0; + var _colorName = _interopRequireDefault(require_color_name()); + var _cssUnitConverter = _interopRequireDefault(require_css_unit_converter()); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { "default": obj }; + } + function _classCallCheck(instance10, Constructor) { + if (!(instance10 instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) + descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) + _defineProperties(Constructor.prototype, protoProps); + if (staticProps) + _defineProperties(Constructor, staticProps); + return Constructor; + } + function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray2(arr, i) || _nonIterableRest(); + } + function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + function _unsupportedIterableToArray2(o, minLen) { + if (!o) + return; + if (typeof o === "string") + return _arrayLikeToArray2(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) + n = o.constructor.name; + if (n === "Map" || n === "Set") + return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) + return _arrayLikeToArray2(o, minLen); + } + function _arrayLikeToArray2(arr, len) { + if (len == null || len > arr.length) + len = arr.length; + for (var i = 0, arr2 = new Array(len); i < len; i++) { + arr2[i] = arr[i]; + } + return arr2; + } + function _iterableToArrayLimit(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) + return; + var _arr = []; + var _n = true; + var _d = false; + var _e = void 0; + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + if (i && _arr.length === i) + break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"] != null) + _i["return"](); + } finally { + if (_d) + throw _e; + } + } + return _arr; + } + function _arrayWithHoles(arr) { + if (Array.isArray(arr)) + return arr; + } + var hex = /^#([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})?$/; + var shortHex = /^#([0-9a-fA-F])([0-9a-fA-F])([0-9a-fA-F])([0-9a-fA-F])?$/; + var rgb = /^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)(?:\s*,\s*(0|1|0?\.\d+|\d+%))?\s*\)$/; + var rgbfn = /^rgba?\(\s*(\d+)\s+(\d+)\s+(\d+)(?:\s*\/\s*(0|1|0?\.\d+|\d+%))?\s*\)$/; + var rgbperc = /^rgba?\(\s*(\d+%)\s*,\s*(\d+%)\s*,\s*(\d+%)(?:\s*,\s*(0|1|0?\.\d+|\d+%))?\s*\)$/; + var rgbpercfn = /^rgba?\(\s*(\d+%)\s+(\d+%)\s+(\d+%)(?:\s*\/\s*(0|1|0?\.\d+|\d+%))?\s*\)$/; + var hsl = /^hsla?\(\s*(\d+)(deg|rad|grad|turn)?\s*,\s*(\d+)%\s*,\s*(\d+)%(?:\s*,\s*(0|1|0?\.\d+|\d+%))?\s*\)$/; + function contains2(haystack, needle) { + return haystack.indexOf(needle) > -1; + } + function rgbToHsl(r, g, b) { + var rprim = r / 255; + var gprim = g / 255; + var bprim = b / 255; + var cmax = Math.max(rprim, gprim, bprim); + var cmin = Math.min(rprim, gprim, bprim); + var delta = cmax - cmin; + var l = (cmax + cmin) / 2; + if (delta === 0) { + return [0, 0, l * 100]; + } + var s = delta / (1 - Math.abs(2 * l - 1)); + var h = function() { + switch (cmax) { + case rprim: { + return (gprim - bprim) / delta % 6; + } + case gprim: { + return (bprim - rprim) / delta + 2; + } + default: { + return (rprim - gprim) / delta + 4; + } + } + }(); + return [h * 60, s * 100, l * 100]; + } + function hslToRgb(h, s, l) { + var hprim = h / 60; + var sprim = s / 100; + var lprim = l / 100; + var c = (1 - Math.abs(2 * lprim - 1)) * sprim; + var x = c * (1 - Math.abs(hprim % 2 - 1)); + var m = lprim - c / 2; + var _ref = function() { + if (hprim < 1) + return [c, x, 0]; + if (hprim < 2) + return [x, c, 0]; + if (hprim < 3) + return [0, c, x]; + if (hprim < 4) + return [0, x, c]; + if (hprim < 5) + return [x, 0, c]; + return [c, 0, x]; + }(), _ref2 = _slicedToArray(_ref, 3), rprim = _ref2[0], gprim = _ref2[1], bprim = _ref2[2]; + return [(rprim + m) * 255, (gprim + m) * 255, (bprim + m) * 255]; + } + var Color = /* @__PURE__ */ function() { + function Color2(_ref3) { + var _ref4 = _slicedToArray(_ref3, 4), r = _ref4[0], g = _ref4[1], b = _ref4[2], a = _ref4[3]; + _classCallCheck(this, Color2); + this.values = [Math.max(Math.min(parseInt(r, 10), 255), 0), Math.max(Math.min(parseInt(g, 10), 255), 0), Math.max(Math.min(parseInt(b, 10), 255), 0), a == null ? 1 : Math.max(Math.min(parseFloat(a), 255), 0)]; + } + _createClass(Color2, [{ + key: "toRgbString", + value: function toRgbString() { + var _this$values = _slicedToArray(this.values, 4), r = _this$values[0], g = _this$values[1], b = _this$values[2], a = _this$values[3]; + if (a === 1) { + return "rgb(".concat(r, ", ").concat(g, ", ").concat(b, ")"); + } + return "rgba(".concat(r, ", ").concat(g, ", ").concat(b, ", ").concat(a, ")"); + } + }, { + key: "toHslString", + value: function toHslString() { + var _this$toHslaArray = this.toHslaArray(), _this$toHslaArray2 = _slicedToArray(_this$toHslaArray, 4), h = _this$toHslaArray2[0], s = _this$toHslaArray2[1], l = _this$toHslaArray2[2], a = _this$toHslaArray2[3]; + if (a === 1) { + return "hsl(".concat(h, ", ").concat(s, "%, ").concat(l, "%)"); + } + return "hsla(".concat(h, ", ").concat(s, "%, ").concat(l, "%, ").concat(a, ")"); + } + }, { + key: "toHexString", + value: function toHexString() { + var _this$values2 = _slicedToArray(this.values, 4), r = _this$values2[0], g = _this$values2[1], b = _this$values2[2], a = _this$values2[3]; + r = Number(r).toString(16).padStart(2, "0"); + g = Number(g).toString(16).padStart(2, "0"); + b = Number(b).toString(16).padStart(2, "0"); + a = a < 1 ? parseInt(a * 255, 10).toString(16).padStart(2, "0") : ""; + return "#".concat(r).concat(g).concat(b).concat(a); + } + }, { + key: "toRgbaArray", + value: function toRgbaArray() { + return this.values; + } + }, { + key: "toHslaArray", + value: function toHslaArray() { + var _this$values3 = _slicedToArray(this.values, 4), r = _this$values3[0], g = _this$values3[1], b = _this$values3[2], a = _this$values3[3]; + var _rgbToHsl = rgbToHsl(r, g, b), _rgbToHsl2 = _slicedToArray(_rgbToHsl, 3), h = _rgbToHsl2[0], s = _rgbToHsl2[1], l = _rgbToHsl2[2]; + return [h, s, l, a]; + } + }]); + return Color2; + }(); + function fromRgba(_ref5) { + var _ref6 = _slicedToArray(_ref5, 4), r = _ref6[0], g = _ref6[1], b = _ref6[2], a = _ref6[3]; + return new Color([r, g, b, a]); + } + function fromRgb(_ref7) { + var _ref8 = _slicedToArray(_ref7, 3), r = _ref8[0], g = _ref8[1], b = _ref8[2]; + return fromRgba([r, g, b, 1]); + } + function fromHsla(_ref9) { + var _ref10 = _slicedToArray(_ref9, 4), h = _ref10[0], s = _ref10[1], l = _ref10[2], a = _ref10[3]; + var _hslToRgb = hslToRgb(h, s, l), _hslToRgb2 = _slicedToArray(_hslToRgb, 3), r = _hslToRgb2[0], g = _hslToRgb2[1], b = _hslToRgb2[2]; + return fromRgba([r, g, b, a]); + } + function fromHsl(_ref11) { + var _ref12 = _slicedToArray(_ref11, 3), h = _ref12[0], s = _ref12[1], l = _ref12[2]; + return fromHsla([h, s, l, 1]); + } + function fromHexString(str) { + var _ref13 = hex.exec(str) || shortHex.exec(str), _ref14 = _slicedToArray(_ref13, 5), r = _ref14[1], g = _ref14[2], b = _ref14[3], a = _ref14[4]; + r = parseInt(r.length < 2 ? r.repeat(2) : r, 16); + g = parseInt(g.length < 2 ? g.repeat(2) : g, 16); + b = parseInt(b.length < 2 ? b.repeat(2) : b, 16); + a = a && (parseInt(a.length < 2 ? a.repeat(2) : a, 16) / 255).toPrecision(1) || 1; + return fromRgba([r, g, b, a]); + } + function fromRgbString(str) { + var _ref15 = rgb.exec(str) || rgbperc.exec(str) || rgbfn.exec(str) || rgbpercfn.exec(str), _ref16 = _slicedToArray(_ref15, 5), r = _ref16[1], g = _ref16[2], b = _ref16[3], a = _ref16[4]; + r = contains2(r, "%") ? parseInt(r, 10) * 255 / 100 : parseInt(r, 10); + g = contains2(g, "%") ? parseInt(g, 10) * 255 / 100 : parseInt(g, 10); + b = contains2(b, "%") > 0 ? parseInt(b, 10) * 255 / 100 : parseInt(b, 10); + a = a === void 0 ? 1 : parseFloat(a) / (contains2(a, "%") ? 100 : 1); + return fromRgba([r, g, b, a]); + } + function fromHslString(str) { + var _hsl$exec = hsl.exec(str), _hsl$exec2 = _slicedToArray(_hsl$exec, 6), h = _hsl$exec2[1], unit = _hsl$exec2[2], s = _hsl$exec2[3], l = _hsl$exec2[4], a = _hsl$exec2[5]; + unit = unit || "deg"; + h = (0, _cssUnitConverter["default"])(parseFloat(h), unit, "deg"); + s = parseFloat(s); + l = parseFloat(l); + a = a === void 0 ? 1 : parseFloat(a) / (contains2(a, "%") ? 100 : 1); + return fromHsla([h, s, l, a]); + } + function fromString2(str) { + if (_colorName["default"][str]) { + return fromRgb(_colorName["default"][str]); + } + if (hex.test(str) || shortHex.test(str)) { + return fromHexString(str); + } + if (rgb.test(str) || rgbperc.test(str) || rgbfn.test(str) || rgbpercfn.test(str)) { + return fromRgbString(str); + } + if (hsl.test(str)) { + return fromHslString(str); + } + return null; + } + var _default = { + fromString: fromString2, + fromRgb, + fromRgba, + fromHsl, + fromHsla + }; + exports2["default"] = _default; + } +}); + +// node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js +var require_isArguments = __commonJS({ + "node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var toStr = Object.prototype.toString; + module2.exports = function isArguments(value) { + var str = toStr.call(value); + var isArgs = str === "[object Arguments]"; + if (!isArgs) { + isArgs = str !== "[object Array]" && value !== null && typeof value === "object" && typeof value.length === "number" && value.length >= 0 && toStr.call(value.callee) === "[object Function]"; + } + return isArgs; + }; + } +}); + +// node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js +var require_implementation = __commonJS({ + "node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var keysShim; + if (!Object.keys) { + has = Object.prototype.hasOwnProperty; + toStr = Object.prototype.toString; + isArgs = require_isArguments(); + isEnumerable = Object.prototype.propertyIsEnumerable; + hasDontEnumBug = !isEnumerable.call({ toString: null }, "toString"); + hasProtoEnumBug = isEnumerable.call(function() { + }, "prototype"); + dontEnums = [ + "toString", + "toLocaleString", + "valueOf", + "hasOwnProperty", + "isPrototypeOf", + "propertyIsEnumerable", + "constructor" + ]; + equalsConstructorPrototype = function(o) { + var ctor = o.constructor; + return ctor && ctor.prototype === o; + }; + excludedKeys = { + $applicationCache: true, + $console: true, + $external: true, + $frame: true, + $frameElement: true, + $frames: true, + $innerHeight: true, + $innerWidth: true, + $onmozfullscreenchange: true, + $onmozfullscreenerror: true, + $outerHeight: true, + $outerWidth: true, + $pageXOffset: true, + $pageYOffset: true, + $parent: true, + $scrollLeft: true, + $scrollTop: true, + $scrollX: true, + $scrollY: true, + $self: true, + $webkitIndexedDB: true, + $webkitStorageInfo: true, + $window: true + }; + hasAutomationEqualityBug = function() { + if (typeof window === "undefined") { + return false; + } + for (var k in window) { + try { + if (!excludedKeys["$" + k] && has.call(window, k) && window[k] !== null && typeof window[k] === "object") { + try { + equalsConstructorPrototype(window[k]); + } catch (e) { + return true; + } + } + } catch (e) { + return true; + } + } + return false; + }(); + equalsConstructorPrototypeIfNotBuggy = function(o) { + if (typeof window === "undefined" || !hasAutomationEqualityBug) { + return equalsConstructorPrototype(o); + } + try { + return equalsConstructorPrototype(o); + } catch (e) { + return false; + } + }; + keysShim = function keys(object) { + var isObject = object !== null && typeof object === "object"; + var isFunction = toStr.call(object) === "[object Function]"; + var isArguments = isArgs(object); + var isString = isObject && toStr.call(object) === "[object String]"; + var theKeys = []; + if (!isObject && !isFunction && !isArguments) { + throw new TypeError("Object.keys called on a non-object"); + } + var skipProto = hasProtoEnumBug && isFunction; + if (isString && object.length > 0 && !has.call(object, 0)) { + for (var i = 0; i < object.length; ++i) { + theKeys.push(String(i)); + } + } + if (isArguments && object.length > 0) { + for (var j = 0; j < object.length; ++j) { + theKeys.push(String(j)); + } + } else { + for (var name in object) { + if (!(skipProto && name === "prototype") && has.call(object, name)) { + theKeys.push(String(name)); + } + } + } + if (hasDontEnumBug) { + var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object); + for (var k = 0; k < dontEnums.length; ++k) { + if (!(skipConstructor && dontEnums[k] === "constructor") && has.call(object, dontEnums[k])) { + theKeys.push(dontEnums[k]); + } + } + } + return theKeys; + }; + } + var has; + var toStr; + var isArgs; + var isEnumerable; + var hasDontEnumBug; + var hasProtoEnumBug; + var dontEnums; + var equalsConstructorPrototype; + var excludedKeys; + var hasAutomationEqualityBug; + var equalsConstructorPrototypeIfNotBuggy; + module2.exports = keysShim; + } +}); + +// node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/index.js +var require_object_keys = __commonJS({ + "node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var slice = Array.prototype.slice; + var isArgs = require_isArguments(); + var origKeys = Object.keys; + var keysShim = origKeys ? function keys(o) { + return origKeys(o); + } : require_implementation(); + var originalKeys = Object.keys; + keysShim.shim = function shimObjectKeys() { + if (Object.keys) { + var keysWorksWithArguments = function() { + var args = Object.keys(arguments); + return args && args.length === arguments.length; + }(1, 2); + if (!keysWorksWithArguments) { + Object.keys = function keys(object) { + if (isArgs(object)) { + return originalKeys(slice.call(object)); + } + return originalKeys(object); + }; + } + } else { + Object.keys = keysShim; + } + return Object.keys || keysShim; + }; + module2.exports = keysShim; + } +}); + +// node_modules/.pnpm/has-symbols@1.0.3/node_modules/has-symbols/shams.js +var require_shams = __commonJS({ + "node_modules/.pnpm/has-symbols@1.0.3/node_modules/has-symbols/shams.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + module2.exports = function hasSymbols() { + if (typeof Symbol !== "function" || typeof Object.getOwnPropertySymbols !== "function") { + return false; + } + if (typeof Symbol.iterator === "symbol") { + return true; + } + var obj = {}; + var sym = Symbol("test"); + var symObj = Object(sym); + if (typeof sym === "string") { + return false; + } + if (Object.prototype.toString.call(sym) !== "[object Symbol]") { + return false; + } + if (Object.prototype.toString.call(symObj) !== "[object Symbol]") { + return false; + } + var symVal = 42; + obj[sym] = symVal; + for (sym in obj) { + return false; + } + if (typeof Object.keys === "function" && Object.keys(obj).length !== 0) { + return false; + } + if (typeof Object.getOwnPropertyNames === "function" && Object.getOwnPropertyNames(obj).length !== 0) { + return false; + } + var syms = Object.getOwnPropertySymbols(obj); + if (syms.length !== 1 || syms[0] !== sym) { + return false; + } + if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { + return false; + } + if (typeof Object.getOwnPropertyDescriptor === "function") { + var descriptor = Object.getOwnPropertyDescriptor(obj, sym); + if (descriptor.value !== symVal || descriptor.enumerable !== true) { + return false; + } + } + return true; + }; + } +}); + +// node_modules/.pnpm/has-symbols@1.0.3/node_modules/has-symbols/index.js +var require_has_symbols = __commonJS({ + "node_modules/.pnpm/has-symbols@1.0.3/node_modules/has-symbols/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var origSymbol = typeof Symbol !== "undefined" && Symbol; + var hasSymbolSham = require_shams(); + module2.exports = function hasNativeSymbols() { + if (typeof origSymbol !== "function") { + return false; + } + if (typeof Symbol !== "function") { + return false; + } + if (typeof origSymbol("foo") !== "symbol") { + return false; + } + if (typeof Symbol("bar") !== "symbol") { + return false; + } + return hasSymbolSham(); + }; + } +}); + +// node_modules/.pnpm/has-proto@1.0.1/node_modules/has-proto/index.js +var require_has_proto = __commonJS({ + "node_modules/.pnpm/has-proto@1.0.1/node_modules/has-proto/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var test = { + foo: {} + }; + var $Object = Object; + module2.exports = function hasProto() { + return { __proto__: test }.foo === test.foo && !({ __proto__: null } instanceof $Object); + }; + } +}); + +// node_modules/.pnpm/function-bind@1.1.1/node_modules/function-bind/implementation.js +var require_implementation2 = __commonJS({ + "node_modules/.pnpm/function-bind@1.1.1/node_modules/function-bind/implementation.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var ERROR_MESSAGE = "Function.prototype.bind called on incompatible "; + var slice = Array.prototype.slice; + var toStr = Object.prototype.toString; + var funcType = "[object Function]"; + module2.exports = function bind(that) { + var target = this; + if (typeof target !== "function" || toStr.call(target) !== funcType) { + throw new TypeError(ERROR_MESSAGE + target); + } + var args = slice.call(arguments, 1); + var bound; + var binder = function() { + if (this instanceof bound) { + var result = target.apply( + this, + args.concat(slice.call(arguments)) + ); + if (Object(result) === result) { + return result; + } + return this; + } else { + return target.apply( + that, + args.concat(slice.call(arguments)) + ); + } + }; + var boundLength = Math.max(0, target.length - args.length); + var boundArgs = []; + for (var i = 0; i < boundLength; i++) { + boundArgs.push("$" + i); + } + bound = Function("binder", "return function (" + boundArgs.join(",") + "){ return binder.apply(this,arguments); }")(binder); + if (target.prototype) { + var Empty = function Empty2() { + }; + Empty.prototype = target.prototype; + bound.prototype = new Empty(); + Empty.prototype = null; + } + return bound; + }; + } +}); + +// node_modules/.pnpm/function-bind@1.1.1/node_modules/function-bind/index.js +var require_function_bind = __commonJS({ + "node_modules/.pnpm/function-bind@1.1.1/node_modules/function-bind/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var implementation = require_implementation2(); + module2.exports = Function.prototype.bind || implementation; + } +}); + +// node_modules/.pnpm/has@1.0.3/node_modules/has/src/index.js +var require_src2 = __commonJS({ + "node_modules/.pnpm/has@1.0.3/node_modules/has/src/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var bind = require_function_bind(); + module2.exports = bind.call(Function.call, Object.prototype.hasOwnProperty); + } +}); + +// node_modules/.pnpm/get-intrinsic@1.2.1/node_modules/get-intrinsic/index.js +var require_get_intrinsic = __commonJS({ + "node_modules/.pnpm/get-intrinsic@1.2.1/node_modules/get-intrinsic/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var undefined2; + var $SyntaxError = SyntaxError; + var $Function = Function; + var $TypeError = TypeError; + var getEvalledConstructor = function(expressionSyntax) { + try { + return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")(); + } catch (e) { + } + }; + var $gOPD = Object.getOwnPropertyDescriptor; + if ($gOPD) { + try { + $gOPD({}, ""); + } catch (e) { + $gOPD = null; + } + } + var throwTypeError = function() { + throw new $TypeError(); + }; + var ThrowTypeError = $gOPD ? function() { + try { + arguments.callee; + return throwTypeError; + } catch (calleeThrows) { + try { + return $gOPD(arguments, "callee").get; + } catch (gOPDthrows) { + return throwTypeError; + } + } + }() : throwTypeError; + var hasSymbols = require_has_symbols()(); + var hasProto = require_has_proto()(); + var getProto = Object.getPrototypeOf || (hasProto ? function(x) { + return x.__proto__; + } : null); + var needsEval = {}; + var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined2 : getProto(Uint8Array); + var INTRINSICS = { + "%AggregateError%": typeof AggregateError === "undefined" ? undefined2 : AggregateError, + "%Array%": Array, + "%ArrayBuffer%": typeof ArrayBuffer === "undefined" ? undefined2 : ArrayBuffer, + "%ArrayIteratorPrototype%": hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined2, + "%AsyncFromSyncIteratorPrototype%": undefined2, + "%AsyncFunction%": needsEval, + "%AsyncGenerator%": needsEval, + "%AsyncGeneratorFunction%": needsEval, + "%AsyncIteratorPrototype%": needsEval, + "%Atomics%": typeof Atomics === "undefined" ? undefined2 : Atomics, + "%BigInt%": typeof BigInt === "undefined" ? undefined2 : BigInt, + "%BigInt64Array%": typeof BigInt64Array === "undefined" ? undefined2 : BigInt64Array, + "%BigUint64Array%": typeof BigUint64Array === "undefined" ? undefined2 : BigUint64Array, + "%Boolean%": Boolean, + "%DataView%": typeof DataView === "undefined" ? undefined2 : DataView, + "%Date%": Date, + "%decodeURI%": decodeURI, + "%decodeURIComponent%": decodeURIComponent, + "%encodeURI%": encodeURI, + "%encodeURIComponent%": encodeURIComponent, + "%Error%": Error, + "%eval%": eval, + // eslint-disable-line no-eval + "%EvalError%": EvalError, + "%Float32Array%": typeof Float32Array === "undefined" ? undefined2 : Float32Array, + "%Float64Array%": typeof Float64Array === "undefined" ? undefined2 : Float64Array, + "%FinalizationRegistry%": typeof FinalizationRegistry === "undefined" ? undefined2 : FinalizationRegistry, + "%Function%": $Function, + "%GeneratorFunction%": needsEval, + "%Int8Array%": typeof Int8Array === "undefined" ? undefined2 : Int8Array, + "%Int16Array%": typeof Int16Array === "undefined" ? undefined2 : Int16Array, + "%Int32Array%": typeof Int32Array === "undefined" ? undefined2 : Int32Array, + "%isFinite%": isFinite, + "%isNaN%": isNaN, + "%IteratorPrototype%": hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined2, + "%JSON%": typeof JSON === "object" ? JSON : undefined2, + "%Map%": typeof Map === "undefined" ? undefined2 : Map, + "%MapIteratorPrototype%": typeof Map === "undefined" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Map())[Symbol.iterator]()), + "%Math%": Math, + "%Number%": Number, + "%Object%": Object, + "%parseFloat%": parseFloat, + "%parseInt%": parseInt, + "%Promise%": typeof Promise === "undefined" ? undefined2 : Promise, + "%Proxy%": typeof Proxy === "undefined" ? undefined2 : Proxy, + "%RangeError%": RangeError, + "%ReferenceError%": ReferenceError, + "%Reflect%": typeof Reflect === "undefined" ? undefined2 : Reflect, + "%RegExp%": RegExp, + "%Set%": typeof Set === "undefined" ? undefined2 : Set, + "%SetIteratorPrototype%": typeof Set === "undefined" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Set())[Symbol.iterator]()), + "%SharedArrayBuffer%": typeof SharedArrayBuffer === "undefined" ? undefined2 : SharedArrayBuffer, + "%String%": String, + "%StringIteratorPrototype%": hasSymbols && getProto ? getProto(""[Symbol.iterator]()) : undefined2, + "%Symbol%": hasSymbols ? Symbol : undefined2, + "%SyntaxError%": $SyntaxError, + "%ThrowTypeError%": ThrowTypeError, + "%TypedArray%": TypedArray, + "%TypeError%": $TypeError, + "%Uint8Array%": typeof Uint8Array === "undefined" ? undefined2 : Uint8Array, + "%Uint8ClampedArray%": typeof Uint8ClampedArray === "undefined" ? undefined2 : Uint8ClampedArray, + "%Uint16Array%": typeof Uint16Array === "undefined" ? undefined2 : Uint16Array, + "%Uint32Array%": typeof Uint32Array === "undefined" ? undefined2 : Uint32Array, + "%URIError%": URIError, + "%WeakMap%": typeof WeakMap === "undefined" ? undefined2 : WeakMap, + "%WeakRef%": typeof WeakRef === "undefined" ? undefined2 : WeakRef, + "%WeakSet%": typeof WeakSet === "undefined" ? undefined2 : WeakSet + }; + if (getProto) { + try { + null.error; + } catch (e) { + errorProto = getProto(getProto(e)); + INTRINSICS["%Error.prototype%"] = errorProto; + } + } + var errorProto; + var doEval = function doEval2(name) { + var value; + if (name === "%AsyncFunction%") { + value = getEvalledConstructor("async function () {}"); + } else if (name === "%GeneratorFunction%") { + value = getEvalledConstructor("function* () {}"); + } else if (name === "%AsyncGeneratorFunction%") { + value = getEvalledConstructor("async function* () {}"); + } else if (name === "%AsyncGenerator%") { + var fn = doEval2("%AsyncGeneratorFunction%"); + if (fn) { + value = fn.prototype; + } + } else if (name === "%AsyncIteratorPrototype%") { + var gen = doEval2("%AsyncGenerator%"); + if (gen && getProto) { + value = getProto(gen.prototype); + } + } + INTRINSICS[name] = value; + return value; + }; + var LEGACY_ALIASES = { + "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"], + "%ArrayPrototype%": ["Array", "prototype"], + "%ArrayProto_entries%": ["Array", "prototype", "entries"], + "%ArrayProto_forEach%": ["Array", "prototype", "forEach"], + "%ArrayProto_keys%": ["Array", "prototype", "keys"], + "%ArrayProto_values%": ["Array", "prototype", "values"], + "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"], + "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"], + "%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype", "prototype"], + "%BooleanPrototype%": ["Boolean", "prototype"], + "%DataViewPrototype%": ["DataView", "prototype"], + "%DatePrototype%": ["Date", "prototype"], + "%ErrorPrototype%": ["Error", "prototype"], + "%EvalErrorPrototype%": ["EvalError", "prototype"], + "%Float32ArrayPrototype%": ["Float32Array", "prototype"], + "%Float64ArrayPrototype%": ["Float64Array", "prototype"], + "%FunctionPrototype%": ["Function", "prototype"], + "%Generator%": ["GeneratorFunction", "prototype"], + "%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"], + "%Int8ArrayPrototype%": ["Int8Array", "prototype"], + "%Int16ArrayPrototype%": ["Int16Array", "prototype"], + "%Int32ArrayPrototype%": ["Int32Array", "prototype"], + "%JSONParse%": ["JSON", "parse"], + "%JSONStringify%": ["JSON", "stringify"], + "%MapPrototype%": ["Map", "prototype"], + "%NumberPrototype%": ["Number", "prototype"], + "%ObjectPrototype%": ["Object", "prototype"], + "%ObjProto_toString%": ["Object", "prototype", "toString"], + "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"], + "%PromisePrototype%": ["Promise", "prototype"], + "%PromiseProto_then%": ["Promise", "prototype", "then"], + "%Promise_all%": ["Promise", "all"], + "%Promise_reject%": ["Promise", "reject"], + "%Promise_resolve%": ["Promise", "resolve"], + "%RangeErrorPrototype%": ["RangeError", "prototype"], + "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"], + "%RegExpPrototype%": ["RegExp", "prototype"], + "%SetPrototype%": ["Set", "prototype"], + "%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"], + "%StringPrototype%": ["String", "prototype"], + "%SymbolPrototype%": ["Symbol", "prototype"], + "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"], + "%TypedArrayPrototype%": ["TypedArray", "prototype"], + "%TypeErrorPrototype%": ["TypeError", "prototype"], + "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"], + "%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"], + "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"], + "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"], + "%URIErrorPrototype%": ["URIError", "prototype"], + "%WeakMapPrototype%": ["WeakMap", "prototype"], + "%WeakSetPrototype%": ["WeakSet", "prototype"] + }; + var bind = require_function_bind(); + var hasOwn = require_src2(); + var $concat = bind.call(Function.call, Array.prototype.concat); + var $spliceApply = bind.call(Function.apply, Array.prototype.splice); + var $replace = bind.call(Function.call, String.prototype.replace); + var $strSlice = bind.call(Function.call, String.prototype.slice); + var $exec = bind.call(Function.call, RegExp.prototype.exec); + var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g; + var reEscapeChar = /\\(\\)?/g; + var stringToPath = function stringToPath2(string) { + var first2 = $strSlice(string, 0, 1); + var last2 = $strSlice(string, -1); + if (first2 === "%" && last2 !== "%") { + throw new $SyntaxError("invalid intrinsic syntax, expected closing `%`"); + } else if (last2 === "%" && first2 !== "%") { + throw new $SyntaxError("invalid intrinsic syntax, expected opening `%`"); + } + var result = []; + $replace(string, rePropName, function(match, number, quote, subString) { + result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number || match; + }); + return result; + }; + var getBaseIntrinsic = function getBaseIntrinsic2(name, allowMissing) { + var intrinsicName = name; + var alias; + if (hasOwn(LEGACY_ALIASES, intrinsicName)) { + alias = LEGACY_ALIASES[intrinsicName]; + intrinsicName = "%" + alias[0] + "%"; + } + if (hasOwn(INTRINSICS, intrinsicName)) { + var value = INTRINSICS[intrinsicName]; + if (value === needsEval) { + value = doEval(intrinsicName); + } + if (typeof value === "undefined" && !allowMissing) { + throw new $TypeError("intrinsic " + name + " exists, but is not available. Please file an issue!"); + } + return { + alias, + name: intrinsicName, + value + }; + } + throw new $SyntaxError("intrinsic " + name + " does not exist!"); + }; + module2.exports = function GetIntrinsic(name, allowMissing) { + if (typeof name !== "string" || name.length === 0) { + throw new $TypeError("intrinsic name must be a non-empty string"); + } + if (arguments.length > 1 && typeof allowMissing !== "boolean") { + throw new $TypeError('"allowMissing" argument must be a boolean'); + } + if ($exec(/^%?[^%]*%?$/, name) === null) { + throw new $SyntaxError("`%` may not be present anywhere but at the beginning and end of the intrinsic name"); + } + var parts = stringToPath(name); + var intrinsicBaseName = parts.length > 0 ? parts[0] : ""; + var intrinsic = getBaseIntrinsic("%" + intrinsicBaseName + "%", allowMissing); + var intrinsicRealName = intrinsic.name; + var value = intrinsic.value; + var skipFurtherCaching = false; + var alias = intrinsic.alias; + if (alias) { + intrinsicBaseName = alias[0]; + $spliceApply(parts, $concat([0, 1], alias)); + } + for (var i = 1, isOwn = true; i < parts.length; i += 1) { + var part = parts[i]; + var first2 = $strSlice(part, 0, 1); + var last2 = $strSlice(part, -1); + if ((first2 === '"' || first2 === "'" || first2 === "`" || (last2 === '"' || last2 === "'" || last2 === "`")) && first2 !== last2) { + throw new $SyntaxError("property names with quotes must have matching quotes"); + } + if (part === "constructor" || !isOwn) { + skipFurtherCaching = true; + } + intrinsicBaseName += "." + part; + intrinsicRealName = "%" + intrinsicBaseName + "%"; + if (hasOwn(INTRINSICS, intrinsicRealName)) { + value = INTRINSICS[intrinsicRealName]; + } else if (value != null) { + if (!(part in value)) { + if (!allowMissing) { + throw new $TypeError("base intrinsic for " + name + " exists, but the property is not available."); + } + return void 0; + } + if ($gOPD && i + 1 >= parts.length) { + var desc = $gOPD(value, part); + isOwn = !!desc; + if (isOwn && "get" in desc && !("originalValue" in desc.get)) { + value = desc.get; + } else { + value = value[part]; + } + } else { + isOwn = hasOwn(value, part); + value = value[part]; + } + if (isOwn && !skipFurtherCaching) { + INTRINSICS[intrinsicRealName] = value; + } + } + } + return value; + }; + } +}); + +// node_modules/.pnpm/has-property-descriptors@1.0.0/node_modules/has-property-descriptors/index.js +var require_has_property_descriptors = __commonJS({ + "node_modules/.pnpm/has-property-descriptors@1.0.0/node_modules/has-property-descriptors/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var GetIntrinsic = require_get_intrinsic(); + var $defineProperty = GetIntrinsic("%Object.defineProperty%", true); + var hasPropertyDescriptors = function hasPropertyDescriptors2() { + if ($defineProperty) { + try { + $defineProperty({}, "a", { value: 1 }); + return true; + } catch (e) { + return false; + } + } + return false; + }; + hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() { + if (!hasPropertyDescriptors()) { + return null; + } + try { + return $defineProperty([], "length", { value: 1 }).length !== 1; + } catch (e) { + return true; + } + }; + module2.exports = hasPropertyDescriptors; + } +}); + +// node_modules/.pnpm/define-properties@1.2.0/node_modules/define-properties/index.js +var require_define_properties = __commonJS({ + "node_modules/.pnpm/define-properties@1.2.0/node_modules/define-properties/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var keys = require_object_keys(); + var hasSymbols = typeof Symbol === "function" && typeof Symbol("foo") === "symbol"; + var toStr = Object.prototype.toString; + var concat = Array.prototype.concat; + var origDefineProperty = Object.defineProperty; + var isFunction = function(fn) { + return typeof fn === "function" && toStr.call(fn) === "[object Function]"; + }; + var hasPropertyDescriptors = require_has_property_descriptors()(); + var supportsDescriptors = origDefineProperty && hasPropertyDescriptors; + var defineProperty = function(object, name, value, predicate) { + if (name in object) { + if (predicate === true) { + if (object[name] === value) { + return; + } + } else if (!isFunction(predicate) || !predicate()) { + return; + } + } + if (supportsDescriptors) { + origDefineProperty(object, name, { + configurable: true, + enumerable: false, + value, + writable: true + }); + } else { + object[name] = value; + } + }; + var defineProperties = function(object, map) { + var predicates = arguments.length > 2 ? arguments[2] : {}; + var props = keys(map); + if (hasSymbols) { + props = concat.call(props, Object.getOwnPropertySymbols(map)); + } + for (var i = 0; i < props.length; i += 1) { + defineProperty(object, props[i], map[props[i]], predicates[props[i]]); + } + }; + defineProperties.supportsDescriptors = !!supportsDescriptors; + module2.exports = defineProperties; + } +}); + +// node_modules/.pnpm/call-bind@1.0.2/node_modules/call-bind/index.js +var require_call_bind = __commonJS({ + "node_modules/.pnpm/call-bind@1.0.2/node_modules/call-bind/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var bind = require_function_bind(); + var GetIntrinsic = require_get_intrinsic(); + var $apply = GetIntrinsic("%Function.prototype.apply%"); + var $call = GetIntrinsic("%Function.prototype.call%"); + var $reflectApply = GetIntrinsic("%Reflect.apply%", true) || bind.call($call, $apply); + var $gOPD = GetIntrinsic("%Object.getOwnPropertyDescriptor%", true); + var $defineProperty = GetIntrinsic("%Object.defineProperty%", true); + var $max = GetIntrinsic("%Math.max%"); + if ($defineProperty) { + try { + $defineProperty({}, "a", { value: 1 }); + } catch (e) { + $defineProperty = null; + } + } + module2.exports = function callBind(originalFunction) { + var func = $reflectApply(bind, $call, arguments); + if ($gOPD && $defineProperty) { + var desc = $gOPD(func, "length"); + if (desc.configurable) { + $defineProperty( + func, + "length", + { value: 1 + $max(0, originalFunction.length - (arguments.length - 1)) } + ); + } + } + return func; + }; + var applyBind = function applyBind2() { + return $reflectApply(bind, $apply, arguments); + }; + if ($defineProperty) { + $defineProperty(module2.exports, "apply", { value: applyBind }); + } else { + module2.exports.apply = applyBind; + } + } +}); + +// node_modules/.pnpm/call-bind@1.0.2/node_modules/call-bind/callBound.js +var require_callBound = __commonJS({ + "node_modules/.pnpm/call-bind@1.0.2/node_modules/call-bind/callBound.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var GetIntrinsic = require_get_intrinsic(); + var callBind = require_call_bind(); + var $indexOf = callBind(GetIntrinsic("String.prototype.indexOf")); + module2.exports = function callBoundIntrinsic(name, allowMissing) { + var intrinsic = GetIntrinsic(name, !!allowMissing); + if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) { + return callBind(intrinsic); + } + return intrinsic; + }; + } +}); + +// node_modules/.pnpm/object.assign@4.1.4/node_modules/object.assign/implementation.js +var require_implementation3 = __commonJS({ + "node_modules/.pnpm/object.assign@4.1.4/node_modules/object.assign/implementation.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var objectKeys = require_object_keys(); + var hasSymbols = require_shams()(); + var callBound = require_callBound(); + var toObject = Object; + var $push = callBound("Array.prototype.push"); + var $propIsEnumerable = callBound("Object.prototype.propertyIsEnumerable"); + var originalGetSymbols = hasSymbols ? Object.getOwnPropertySymbols : null; + module2.exports = function assign2(target, source1) { + if (target == null) { + throw new TypeError("target must be an object"); + } + var to = toObject(target); + if (arguments.length === 1) { + return to; + } + for (var s = 1; s < arguments.length; ++s) { + var from = toObject(arguments[s]); + var keys = objectKeys(from); + var getSymbols = hasSymbols && (Object.getOwnPropertySymbols || originalGetSymbols); + if (getSymbols) { + var syms = getSymbols(from); + for (var j = 0; j < syms.length; ++j) { + var key2 = syms[j]; + if ($propIsEnumerable(from, key2)) { + $push(keys, key2); + } + } + } + for (var i = 0; i < keys.length; ++i) { + var nextKey = keys[i]; + if ($propIsEnumerable(from, nextKey)) { + var propValue = from[nextKey]; + to[nextKey] = propValue; + } + } + } + return to; + }; + } +}); + +// node_modules/.pnpm/object.assign@4.1.4/node_modules/object.assign/polyfill.js +var require_polyfill = __commonJS({ + "node_modules/.pnpm/object.assign@4.1.4/node_modules/object.assign/polyfill.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var implementation = require_implementation3(); + var lacksProperEnumerationOrder = function() { + if (!Object.assign) { + return false; + } + var str = "abcdefghijklmnopqrst"; + var letters = str.split(""); + var map = {}; + for (var i = 0; i < letters.length; ++i) { + map[letters[i]] = letters[i]; + } + var obj = Object.assign({}, map); + var actual = ""; + for (var k in obj) { + actual += k; + } + return str !== actual; + }; + var assignHasPendingExceptions = function() { + if (!Object.assign || !Object.preventExtensions) { + return false; + } + var thrower = Object.preventExtensions({ 1: 2 }); + try { + Object.assign(thrower, "xy"); + } catch (e) { + return thrower[1] === "y"; + } + return false; + }; + module2.exports = function getPolyfill() { + if (!Object.assign) { + return implementation; + } + if (lacksProperEnumerationOrder()) { + return implementation; + } + if (assignHasPendingExceptions()) { + return implementation; + } + return Object.assign; + }; + } +}); + +// node_modules/.pnpm/object.assign@4.1.4/node_modules/object.assign/shim.js +var require_shim = __commonJS({ + "node_modules/.pnpm/object.assign@4.1.4/node_modules/object.assign/shim.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var define2 = require_define_properties(); + var getPolyfill = require_polyfill(); + module2.exports = function shimAssign() { + var polyfill = getPolyfill(); + define2( + Object, + { assign: polyfill }, + { assign: function() { + return Object.assign !== polyfill; + } } + ); + return polyfill; + }; + } +}); + +// node_modules/.pnpm/object.assign@4.1.4/node_modules/object.assign/index.js +var require_object = __commonJS({ + "node_modules/.pnpm/object.assign@4.1.4/node_modules/object.assign/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var defineProperties = require_define_properties(); + var callBind = require_call_bind(); + var implementation = require_implementation3(); + var getPolyfill = require_polyfill(); + var shim = require_shim(); + var polyfill = callBind.apply(getPolyfill()); + var bound = function assign2(target, source1) { + return polyfill(Object, arguments); + }; + defineProperties(bound, { + getPolyfill, + implementation, + shim + }); + module2.exports = bound; + } +}); + +// node_modules/.pnpm/functions-have-names@1.2.3/node_modules/functions-have-names/index.js +var require_functions_have_names = __commonJS({ + "node_modules/.pnpm/functions-have-names@1.2.3/node_modules/functions-have-names/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var functionsHaveNames = function functionsHaveNames2() { + return typeof function f() { + }.name === "string"; + }; + var gOPD = Object.getOwnPropertyDescriptor; + if (gOPD) { + try { + gOPD([], "length"); + } catch (e) { + gOPD = null; + } + } + functionsHaveNames.functionsHaveConfigurableNames = function functionsHaveConfigurableNames() { + if (!functionsHaveNames() || !gOPD) { + return false; + } + var desc = gOPD(function() { + }, "name"); + return !!desc && !!desc.configurable; + }; + var $bind = Function.prototype.bind; + functionsHaveNames.boundFunctionsHaveNames = function boundFunctionsHaveNames() { + return functionsHaveNames() && typeof $bind === "function" && function f() { + }.bind().name !== ""; + }; + module2.exports = functionsHaveNames; + } +}); + +// node_modules/.pnpm/regexp.prototype.flags@1.5.0/node_modules/regexp.prototype.flags/implementation.js +var require_implementation4 = __commonJS({ + "node_modules/.pnpm/regexp.prototype.flags@1.5.0/node_modules/regexp.prototype.flags/implementation.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var functionsHaveConfigurableNames = require_functions_have_names().functionsHaveConfigurableNames(); + var $Object = Object; + var $TypeError = TypeError; + module2.exports = function flags() { + if (this != null && this !== $Object(this)) { + throw new $TypeError("RegExp.prototype.flags getter called on non-object"); + } + var result = ""; + if (this.hasIndices) { + result += "d"; + } + if (this.global) { + result += "g"; + } + if (this.ignoreCase) { + result += "i"; + } + if (this.multiline) { + result += "m"; + } + if (this.dotAll) { + result += "s"; + } + if (this.unicode) { + result += "u"; + } + if (this.unicodeSets) { + result += "v"; + } + if (this.sticky) { + result += "y"; + } + return result; + }; + if (functionsHaveConfigurableNames && Object.defineProperty) { + Object.defineProperty(module2.exports, "name", { value: "get flags" }); + } + } +}); + +// node_modules/.pnpm/regexp.prototype.flags@1.5.0/node_modules/regexp.prototype.flags/polyfill.js +var require_polyfill2 = __commonJS({ + "node_modules/.pnpm/regexp.prototype.flags@1.5.0/node_modules/regexp.prototype.flags/polyfill.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var implementation = require_implementation4(); + var supportsDescriptors = require_define_properties().supportsDescriptors; + var $gOPD = Object.getOwnPropertyDescriptor; + module2.exports = function getPolyfill() { + if (supportsDescriptors && /a/mig.flags === "gim") { + var descriptor = $gOPD(RegExp.prototype, "flags"); + if (descriptor && typeof descriptor.get === "function" && typeof RegExp.prototype.dotAll === "boolean" && typeof RegExp.prototype.hasIndices === "boolean") { + var calls = ""; + var o = {}; + Object.defineProperty(o, "hasIndices", { + get: function() { + calls += "d"; + } + }); + Object.defineProperty(o, "sticky", { + get: function() { + calls += "y"; + } + }); + if (calls === "dy") { + return descriptor.get; + } + } + } + return implementation; + }; + } +}); + +// node_modules/.pnpm/regexp.prototype.flags@1.5.0/node_modules/regexp.prototype.flags/shim.js +var require_shim2 = __commonJS({ + "node_modules/.pnpm/regexp.prototype.flags@1.5.0/node_modules/regexp.prototype.flags/shim.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var supportsDescriptors = require_define_properties().supportsDescriptors; + var getPolyfill = require_polyfill2(); + var gOPD = Object.getOwnPropertyDescriptor; + var defineProperty = Object.defineProperty; + var TypeErr = TypeError; + var getProto = Object.getPrototypeOf; + var regex2 = /a/; + module2.exports = function shimFlags() { + if (!supportsDescriptors || !getProto) { + throw new TypeErr("RegExp.prototype.flags requires a true ES5 environment that supports property descriptors"); + } + var polyfill = getPolyfill(); + var proto = getProto(regex2); + var descriptor = gOPD(proto, "flags"); + if (!descriptor || descriptor.get !== polyfill) { + defineProperty(proto, "flags", { + configurable: true, + enumerable: false, + get: polyfill + }); + } + return polyfill; + }; + } +}); + +// node_modules/.pnpm/regexp.prototype.flags@1.5.0/node_modules/regexp.prototype.flags/index.js +var require_regexp_prototype = __commonJS({ + "node_modules/.pnpm/regexp.prototype.flags@1.5.0/node_modules/regexp.prototype.flags/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var define2 = require_define_properties(); + var callBind = require_call_bind(); + var implementation = require_implementation4(); + var getPolyfill = require_polyfill2(); + var shim = require_shim2(); + var flagsBound = callBind(getPolyfill()); + define2(flagsBound, { + getPolyfill, + implementation, + shim + }); + module2.exports = flagsBound; + } +}); + +// node_modules/.pnpm/has-tostringtag@1.0.0/node_modules/has-tostringtag/shams.js +var require_shams2 = __commonJS({ + "node_modules/.pnpm/has-tostringtag@1.0.0/node_modules/has-tostringtag/shams.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var hasSymbols = require_shams(); + module2.exports = function hasToStringTagShams() { + return hasSymbols() && !!Symbol.toStringTag; + }; + } +}); + +// node_modules/.pnpm/is-arguments@1.1.1/node_modules/is-arguments/index.js +var require_is_arguments = __commonJS({ + "node_modules/.pnpm/is-arguments@1.1.1/node_modules/is-arguments/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var hasToStringTag = require_shams2()(); + var callBound = require_callBound(); + var $toString = callBound("Object.prototype.toString"); + var isStandardArguments = function isArguments(value) { + if (hasToStringTag && value && typeof value === "object" && Symbol.toStringTag in value) { + return false; + } + return $toString(value) === "[object Arguments]"; + }; + var isLegacyArguments = function isArguments(value) { + if (isStandardArguments(value)) { + return true; + } + return value !== null && typeof value === "object" && typeof value.length === "number" && value.length >= 0 && $toString(value) !== "[object Array]" && $toString(value.callee) === "[object Function]"; + }; + var supportsStandardArguments = function() { + return isStandardArguments(arguments); + }(); + isStandardArguments.isLegacyArguments = isLegacyArguments; + module2.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments; + } +}); + +// (disabled):node_modules/.pnpm/object-inspect@1.12.3/node_modules/object-inspect/util.inspect +var require_util = __commonJS({ + "(disabled):node_modules/.pnpm/object-inspect@1.12.3/node_modules/object-inspect/util.inspect"() { + init_polyfill_buffer(); + } +}); + +// node_modules/.pnpm/object-inspect@1.12.3/node_modules/object-inspect/index.js +var require_object_inspect = __commonJS({ + "node_modules/.pnpm/object-inspect@1.12.3/node_modules/object-inspect/index.js"(exports2, module2) { + init_polyfill_buffer(); + var hasMap = typeof Map === "function" && Map.prototype; + var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, "size") : null; + var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === "function" ? mapSizeDescriptor.get : null; + var mapForEach = hasMap && Map.prototype.forEach; + var hasSet = typeof Set === "function" && Set.prototype; + var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, "size") : null; + var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === "function" ? setSizeDescriptor.get : null; + var setForEach = hasSet && Set.prototype.forEach; + var hasWeakMap = typeof WeakMap === "function" && WeakMap.prototype; + var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null; + var hasWeakSet = typeof WeakSet === "function" && WeakSet.prototype; + var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null; + var hasWeakRef = typeof WeakRef === "function" && WeakRef.prototype; + var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null; + var booleanValueOf = Boolean.prototype.valueOf; + var objectToString2 = Object.prototype.toString; + var functionToString = Function.prototype.toString; + var $match = String.prototype.match; + var $slice = String.prototype.slice; + var $replace = String.prototype.replace; + var $toUpperCase = String.prototype.toUpperCase; + var $toLowerCase = String.prototype.toLowerCase; + var $test = RegExp.prototype.test; + var $concat = Array.prototype.concat; + var $join = Array.prototype.join; + var $arrSlice = Array.prototype.slice; + var $floor = Math.floor; + var bigIntValueOf = typeof BigInt === "function" ? BigInt.prototype.valueOf : null; + var gOPS = Object.getOwnPropertySymbols; + var symToString = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? Symbol.prototype.toString : null; + var hasShammedSymbols = typeof Symbol === "function" && typeof Symbol.iterator === "object"; + var toStringTag = typeof Symbol === "function" && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? "object" : "symbol") ? Symbol.toStringTag : null; + var isEnumerable = Object.prototype.propertyIsEnumerable; + var gPO = (typeof Reflect === "function" ? Reflect.getPrototypeOf : Object.getPrototypeOf) || ([].__proto__ === Array.prototype ? function(O) { + return O.__proto__; + } : null); + function addNumericSeparator(num2, str) { + if (num2 === Infinity || num2 === -Infinity || num2 !== num2 || num2 && num2 > -1e3 && num2 < 1e3 || $test.call(/e/, str)) { + return str; + } + var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g; + if (typeof num2 === "number") { + var int = num2 < 0 ? -$floor(-num2) : $floor(num2); + if (int !== num2) { + var intStr = String(int); + var dec = $slice.call(str, intStr.length + 1); + return $replace.call(intStr, sepRegex, "$&_") + "." + $replace.call($replace.call(dec, /([0-9]{3})/g, "$&_"), /_$/, ""); + } + } + return $replace.call(str, sepRegex, "$&_"); + } + var utilInspect = require_util(); + var inspectCustom = utilInspect.custom; + var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null; + module2.exports = function inspect_(obj, options, depth, seen) { + var opts = options || {}; + if (has(opts, "quoteStyle") && (opts.quoteStyle !== "single" && opts.quoteStyle !== "double")) { + throw new TypeError('option "quoteStyle" must be "single" or "double"'); + } + if (has(opts, "maxStringLength") && (typeof opts.maxStringLength === "number" ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity : opts.maxStringLength !== null)) { + throw new TypeError('option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`'); + } + var customInspect = has(opts, "customInspect") ? opts.customInspect : true; + if (typeof customInspect !== "boolean" && customInspect !== "symbol") { + throw new TypeError("option \"customInspect\", if provided, must be `true`, `false`, or `'symbol'`"); + } + if (has(opts, "indent") && opts.indent !== null && opts.indent !== " " && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)) { + throw new TypeError('option "indent" must be "\\t", an integer > 0, or `null`'); + } + if (has(opts, "numericSeparator") && typeof opts.numericSeparator !== "boolean") { + throw new TypeError('option "numericSeparator", if provided, must be `true` or `false`'); + } + var numericSeparator = opts.numericSeparator; + if (typeof obj === "undefined") { + return "undefined"; + } + if (obj === null) { + return "null"; + } + if (typeof obj === "boolean") { + return obj ? "true" : "false"; + } + if (typeof obj === "string") { + return inspectString(obj, opts); + } + if (typeof obj === "number") { + if (obj === 0) { + return Infinity / obj > 0 ? "0" : "-0"; + } + var str = String(obj); + return numericSeparator ? addNumericSeparator(obj, str) : str; + } + if (typeof obj === "bigint") { + var bigIntStr = String(obj) + "n"; + return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr; + } + var maxDepth = typeof opts.depth === "undefined" ? 5 : opts.depth; + if (typeof depth === "undefined") { + depth = 0; + } + if (depth >= maxDepth && maxDepth > 0 && typeof obj === "object") { + return isArray(obj) ? "[Array]" : "[Object]"; + } + var indent2 = getIndent(opts, depth); + if (typeof seen === "undefined") { + seen = []; + } else if (indexOf(seen, obj) >= 0) { + return "[Circular]"; + } + function inspect(value, from, noIndent) { + if (from) { + seen = $arrSlice.call(seen); + seen.push(from); + } + if (noIndent) { + var newOpts = { + depth: opts.depth + }; + if (has(opts, "quoteStyle")) { + newOpts.quoteStyle = opts.quoteStyle; + } + return inspect_(value, newOpts, depth + 1, seen); + } + return inspect_(value, opts, depth + 1, seen); + } + if (typeof obj === "function" && !isRegExp(obj)) { + var name = nameOf(obj); + var keys = arrObjKeys(obj, inspect); + return "[Function" + (name ? ": " + name : " (anonymous)") + "]" + (keys.length > 0 ? " { " + $join.call(keys, ", ") + " }" : ""); + } + if (isSymbol(obj)) { + var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\(.*\))_[^)]*$/, "$1") : symToString.call(obj); + return typeof obj === "object" && !hasShammedSymbols ? markBoxed(symString) : symString; + } + if (isElement(obj)) { + var s = "<" + $toLowerCase.call(String(obj.nodeName)); + var attrs = obj.attributes || []; + for (var i = 0; i < attrs.length; i++) { + s += " " + attrs[i].name + "=" + wrapQuotes(quote(attrs[i].value), "double", opts); + } + s += ">"; + if (obj.childNodes && obj.childNodes.length) { + s += "..."; + } + s += ""; + return s; + } + if (isArray(obj)) { + if (obj.length === 0) { + return "[]"; + } + var xs = arrObjKeys(obj, inspect); + if (indent2 && !singleLineValues(xs)) { + return "[" + indentedJoin(xs, indent2) + "]"; + } + return "[ " + $join.call(xs, ", ") + " ]"; + } + if (isError(obj)) { + var parts = arrObjKeys(obj, inspect); + if (!("cause" in Error.prototype) && "cause" in obj && !isEnumerable.call(obj, "cause")) { + return "{ [" + String(obj) + "] " + $join.call($concat.call("[cause]: " + inspect(obj.cause), parts), ", ") + " }"; + } + if (parts.length === 0) { + return "[" + String(obj) + "]"; + } + return "{ [" + String(obj) + "] " + $join.call(parts, ", ") + " }"; + } + if (typeof obj === "object" && customInspect) { + if (inspectSymbol && typeof obj[inspectSymbol] === "function" && utilInspect) { + return utilInspect(obj, { depth: maxDepth - depth }); + } else if (customInspect !== "symbol" && typeof obj.inspect === "function") { + return obj.inspect(); + } + } + if (isMap(obj)) { + var mapParts = []; + if (mapForEach) { + mapForEach.call(obj, function(value, key2) { + mapParts.push(inspect(key2, obj, true) + " => " + inspect(value, obj)); + }); + } + return collectionOf("Map", mapSize.call(obj), mapParts, indent2); + } + if (isSet(obj)) { + var setParts = []; + if (setForEach) { + setForEach.call(obj, function(value) { + setParts.push(inspect(value, obj)); + }); + } + return collectionOf("Set", setSize.call(obj), setParts, indent2); + } + if (isWeakMap(obj)) { + return weakCollectionOf("WeakMap"); + } + if (isWeakSet(obj)) { + return weakCollectionOf("WeakSet"); + } + if (isWeakRef(obj)) { + return weakCollectionOf("WeakRef"); + } + if (isNumber(obj)) { + return markBoxed(inspect(Number(obj))); + } + if (isBigInt(obj)) { + return markBoxed(inspect(bigIntValueOf.call(obj))); + } + if (isBoolean(obj)) { + return markBoxed(booleanValueOf.call(obj)); + } + if (isString(obj)) { + return markBoxed(inspect(String(obj))); + } + if (!isDate(obj) && !isRegExp(obj)) { + var ys = arrObjKeys(obj, inspect); + var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object; + var protoTag = obj instanceof Object ? "" : "null prototype"; + var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? "Object" : ""; + var constructorTag = isPlainObject || typeof obj.constructor !== "function" ? "" : obj.constructor.name ? obj.constructor.name + " " : ""; + var tag2 = constructorTag + (stringTag || protoTag ? "[" + $join.call($concat.call([], stringTag || [], protoTag || []), ": ") + "] " : ""); + if (ys.length === 0) { + return tag2 + "{}"; + } + if (indent2) { + return tag2 + "{" + indentedJoin(ys, indent2) + "}"; + } + return tag2 + "{ " + $join.call(ys, ", ") + " }"; + } + return String(obj); + }; + function wrapQuotes(s, defaultStyle, opts) { + var quoteChar = (opts.quoteStyle || defaultStyle) === "double" ? '"' : "'"; + return quoteChar + s + quoteChar; + } + function quote(s) { + return $replace.call(String(s), /"/g, """); + } + function isArray(obj) { + return toStr(obj) === "[object Array]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj)); + } + function isDate(obj) { + return toStr(obj) === "[object Date]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj)); + } + function isRegExp(obj) { + return toStr(obj) === "[object RegExp]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj)); + } + function isError(obj) { + return toStr(obj) === "[object Error]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj)); + } + function isString(obj) { + return toStr(obj) === "[object String]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj)); + } + function isNumber(obj) { + return toStr(obj) === "[object Number]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj)); + } + function isBoolean(obj) { + return toStr(obj) === "[object Boolean]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj)); + } + function isSymbol(obj) { + if (hasShammedSymbols) { + return obj && typeof obj === "object" && obj instanceof Symbol; + } + if (typeof obj === "symbol") { + return true; + } + if (!obj || typeof obj !== "object" || !symToString) { + return false; + } + try { + symToString.call(obj); + return true; + } catch (e) { + } + return false; + } + function isBigInt(obj) { + if (!obj || typeof obj !== "object" || !bigIntValueOf) { + return false; + } + try { + bigIntValueOf.call(obj); + return true; + } catch (e) { + } + return false; + } + var hasOwn = Object.prototype.hasOwnProperty || function(key2) { + return key2 in this; + }; + function has(obj, key2) { + return hasOwn.call(obj, key2); + } + function toStr(obj) { + return objectToString2.call(obj); + } + function nameOf(f) { + if (f.name) { + return f.name; + } + var m = $match.call(functionToString.call(f), /^function\s*([\w$]+)/); + if (m) { + return m[1]; + } + return null; + } + function indexOf(xs, x) { + if (xs.indexOf) { + return xs.indexOf(x); + } + for (var i = 0, l = xs.length; i < l; i++) { + if (xs[i] === x) { + return i; + } + } + return -1; + } + function isMap(x) { + if (!mapSize || !x || typeof x !== "object") { + return false; + } + try { + mapSize.call(x); + try { + setSize.call(x); + } catch (s) { + return true; + } + return x instanceof Map; + } catch (e) { + } + return false; + } + function isWeakMap(x) { + if (!weakMapHas || !x || typeof x !== "object") { + return false; + } + try { + weakMapHas.call(x, weakMapHas); + try { + weakSetHas.call(x, weakSetHas); + } catch (s) { + return true; + } + return x instanceof WeakMap; + } catch (e) { + } + return false; + } + function isWeakRef(x) { + if (!weakRefDeref || !x || typeof x !== "object") { + return false; + } + try { + weakRefDeref.call(x); + return true; + } catch (e) { + } + return false; + } + function isSet(x) { + if (!setSize || !x || typeof x !== "object") { + return false; + } + try { + setSize.call(x); + try { + mapSize.call(x); + } catch (m) { + return true; + } + return x instanceof Set; + } catch (e) { + } + return false; + } + function isWeakSet(x) { + if (!weakSetHas || !x || typeof x !== "object") { + return false; + } + try { + weakSetHas.call(x, weakSetHas); + try { + weakMapHas.call(x, weakMapHas); + } catch (s) { + return true; + } + return x instanceof WeakSet; + } catch (e) { + } + return false; + } + function isElement(x) { + if (!x || typeof x !== "object") { + return false; + } + if (typeof HTMLElement !== "undefined" && x instanceof HTMLElement) { + return true; + } + return typeof x.nodeName === "string" && typeof x.getAttribute === "function"; + } + function inspectString(str, opts) { + if (str.length > opts.maxStringLength) { + var remaining = str.length - opts.maxStringLength; + var trailer = "... " + remaining + " more character" + (remaining > 1 ? "s" : ""); + return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer; + } + var s = $replace.call($replace.call(str, /(['\\])/g, "\\$1"), /[\x00-\x1f]/g, lowbyte); + return wrapQuotes(s, "single", opts); + } + function lowbyte(c) { + var n = c.charCodeAt(0); + var x = { + 8: "b", + 9: "t", + 10: "n", + 12: "f", + 13: "r" + }[n]; + if (x) { + return "\\" + x; + } + return "\\x" + (n < 16 ? "0" : "") + $toUpperCase.call(n.toString(16)); + } + function markBoxed(str) { + return "Object(" + str + ")"; + } + function weakCollectionOf(type) { + return type + " { ? }"; + } + function collectionOf(type, size, entries, indent2) { + var joinedEntries = indent2 ? indentedJoin(entries, indent2) : $join.call(entries, ", "); + return type + " (" + size + ") {" + joinedEntries + "}"; + } + function singleLineValues(xs) { + for (var i = 0; i < xs.length; i++) { + if (indexOf(xs[i], "\n") >= 0) { + return false; + } + } + return true; + } + function getIndent(opts, depth) { + var baseIndent; + if (opts.indent === " ") { + baseIndent = " "; + } else if (typeof opts.indent === "number" && opts.indent > 0) { + baseIndent = $join.call(Array(opts.indent + 1), " "); + } else { + return null; + } + return { + base: baseIndent, + prev: $join.call(Array(depth + 1), baseIndent) + }; + } + function indentedJoin(xs, indent2) { + if (xs.length === 0) { + return ""; + } + var lineJoiner = "\n" + indent2.prev + indent2.base; + return lineJoiner + $join.call(xs, "," + lineJoiner) + "\n" + indent2.prev; + } + function arrObjKeys(obj, inspect) { + var isArr = isArray(obj); + var xs = []; + if (isArr) { + xs.length = obj.length; + for (var i = 0; i < obj.length; i++) { + xs[i] = has(obj, i) ? inspect(obj[i], obj) : ""; + } + } + var syms = typeof gOPS === "function" ? gOPS(obj) : []; + var symMap; + if (hasShammedSymbols) { + symMap = {}; + for (var k = 0; k < syms.length; k++) { + symMap["$" + syms[k]] = syms[k]; + } + } + for (var key2 in obj) { + if (!has(obj, key2)) { + continue; + } + if (isArr && String(Number(key2)) === key2 && key2 < obj.length) { + continue; + } + if (hasShammedSymbols && symMap["$" + key2] instanceof Symbol) { + continue; + } else if ($test.call(/[^\w$]/, key2)) { + xs.push(inspect(key2, obj) + ": " + inspect(obj[key2], obj)); + } else { + xs.push(key2 + ": " + inspect(obj[key2], obj)); + } + } + if (typeof gOPS === "function") { + for (var j = 0; j < syms.length; j++) { + if (isEnumerable.call(obj, syms[j])) { + xs.push("[" + inspect(syms[j]) + "]: " + inspect(obj[syms[j]], obj)); + } + } + } + return xs; + } + } +}); + +// node_modules/.pnpm/side-channel@1.0.4/node_modules/side-channel/index.js +var require_side_channel = __commonJS({ + "node_modules/.pnpm/side-channel@1.0.4/node_modules/side-channel/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var GetIntrinsic = require_get_intrinsic(); + var callBound = require_callBound(); + var inspect = require_object_inspect(); + var $TypeError = GetIntrinsic("%TypeError%"); + var $WeakMap = GetIntrinsic("%WeakMap%", true); + var $Map = GetIntrinsic("%Map%", true); + var $weakMapGet = callBound("WeakMap.prototype.get", true); + var $weakMapSet = callBound("WeakMap.prototype.set", true); + var $weakMapHas = callBound("WeakMap.prototype.has", true); + var $mapGet = callBound("Map.prototype.get", true); + var $mapSet = callBound("Map.prototype.set", true); + var $mapHas = callBound("Map.prototype.has", true); + var listGetNode = function(list, key2) { + for (var prev = list, curr; (curr = prev.next) !== null; prev = curr) { + if (curr.key === key2) { + prev.next = curr.next; + curr.next = list.next; + list.next = curr; + return curr; + } + } + }; + var listGet = function(objects, key2) { + var node = listGetNode(objects, key2); + return node && node.value; + }; + var listSet = function(objects, key2, value) { + var node = listGetNode(objects, key2); + if (node) { + node.value = value; + } else { + objects.next = { + // eslint-disable-line no-param-reassign + key: key2, + next: objects.next, + value + }; + } + }; + var listHas = function(objects, key2) { + return !!listGetNode(objects, key2); + }; + module2.exports = function getSideChannel() { + var $wm; + var $m; + var $o; + var channel = { + assert: function(key2) { + if (!channel.has(key2)) { + throw new $TypeError("Side channel does not contain " + inspect(key2)); + } + }, + get: function(key2) { + if ($WeakMap && key2 && (typeof key2 === "object" || typeof key2 === "function")) { + if ($wm) { + return $weakMapGet($wm, key2); + } + } else if ($Map) { + if ($m) { + return $mapGet($m, key2); + } + } else { + if ($o) { + return listGet($o, key2); + } + } + }, + has: function(key2) { + if ($WeakMap && key2 && (typeof key2 === "object" || typeof key2 === "function")) { + if ($wm) { + return $weakMapHas($wm, key2); + } + } else if ($Map) { + if ($m) { + return $mapHas($m, key2); + } + } else { + if ($o) { + return listHas($o, key2); + } + } + return false; + }, + set: function(key2, value) { + if ($WeakMap && key2 && (typeof key2 === "object" || typeof key2 === "function")) { + if (!$wm) { + $wm = new $WeakMap(); + } + $weakMapSet($wm, key2, value); + } else if ($Map) { + if (!$m) { + $m = new $Map(); + } + $mapSet($m, key2, value); + } else { + if (!$o) { + $o = { key: {}, next: null }; + } + listSet($o, key2, value); + } + } + }; + return channel; + }; + } +}); + +// node_modules/.pnpm/internal-slot@1.0.5/node_modules/internal-slot/index.js +var require_internal_slot = __commonJS({ + "node_modules/.pnpm/internal-slot@1.0.5/node_modules/internal-slot/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var GetIntrinsic = require_get_intrinsic(); + var has = require_src2(); + var channel = require_side_channel()(); + var $TypeError = GetIntrinsic("%TypeError%"); + var SLOT = { + assert: function(O, slot) { + if (!O || typeof O !== "object" && typeof O !== "function") { + throw new $TypeError("`O` is not an object"); + } + if (typeof slot !== "string") { + throw new $TypeError("`slot` must be a string"); + } + channel.assert(O); + if (!SLOT.has(O, slot)) { + throw new $TypeError("`" + slot + "` is not present on `O`"); + } + }, + get: function(O, slot) { + if (!O || typeof O !== "object" && typeof O !== "function") { + throw new $TypeError("`O` is not an object"); + } + if (typeof slot !== "string") { + throw new $TypeError("`slot` must be a string"); + } + var slots = channel.get(O); + return slots && slots["$" + slot]; + }, + has: function(O, slot) { + if (!O || typeof O !== "object" && typeof O !== "function") { + throw new $TypeError("`O` is not an object"); + } + if (typeof slot !== "string") { + throw new $TypeError("`slot` must be a string"); + } + var slots = channel.get(O); + return !!slots && has(slots, "$" + slot); + }, + set: function(O, slot, V) { + if (!O || typeof O !== "object" && typeof O !== "function") { + throw new $TypeError("`O` is not an object"); + } + if (typeof slot !== "string") { + throw new $TypeError("`slot` must be a string"); + } + var slots = channel.get(O); + if (!slots) { + slots = {}; + channel.set(O, slots); + } + slots["$" + slot] = V; + } + }; + if (Object.freeze) { + Object.freeze(SLOT); + } + module2.exports = SLOT; + } +}); + +// node_modules/.pnpm/stop-iteration-iterator@1.0.0/node_modules/stop-iteration-iterator/index.js +var require_stop_iteration_iterator = __commonJS({ + "node_modules/.pnpm/stop-iteration-iterator@1.0.0/node_modules/stop-iteration-iterator/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var SLOT = require_internal_slot(); + var $SyntaxError = SyntaxError; + var $StopIteration = typeof StopIteration === "object" ? StopIteration : null; + module2.exports = function getStopIterationIterator(origIterator) { + if (!$StopIteration) { + throw new $SyntaxError("this environment lacks StopIteration"); + } + SLOT.set(origIterator, "[[Done]]", false); + var siIterator = { + next: function next() { + var iterator = SLOT.get(this, "[[Iterator]]"); + var done = SLOT.get(iterator, "[[Done]]"); + try { + return { + done, + value: done ? void 0 : iterator.next() + }; + } catch (e) { + SLOT.set(iterator, "[[Done]]", true); + if (e !== $StopIteration) { + throw e; + } + return { + done: true, + value: void 0 + }; + } + } + }; + SLOT.set(siIterator, "[[Iterator]]", origIterator); + return siIterator; + }; + } +}); + +// node_modules/.pnpm/isarray@2.0.5/node_modules/isarray/index.js +var require_isarray = __commonJS({ + "node_modules/.pnpm/isarray@2.0.5/node_modules/isarray/index.js"(exports2, module2) { + init_polyfill_buffer(); + var toString = {}.toString; + module2.exports = Array.isArray || function(arr) { + return toString.call(arr) == "[object Array]"; + }; + } +}); + +// node_modules/.pnpm/is-string@1.0.7/node_modules/is-string/index.js +var require_is_string = __commonJS({ + "node_modules/.pnpm/is-string@1.0.7/node_modules/is-string/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var strValue = String.prototype.valueOf; + var tryStringObject = function tryStringObject2(value) { + try { + strValue.call(value); + return true; + } catch (e) { + return false; + } + }; + var toStr = Object.prototype.toString; + var strClass = "[object String]"; + var hasToStringTag = require_shams2()(); + module2.exports = function isString(value) { + if (typeof value === "string") { + return true; + } + if (typeof value !== "object") { + return false; + } + return hasToStringTag ? tryStringObject(value) : toStr.call(value) === strClass; + }; + } +}); + +// node_modules/.pnpm/is-map@2.0.2/node_modules/is-map/index.js +var require_is_map = __commonJS({ + "node_modules/.pnpm/is-map@2.0.2/node_modules/is-map/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var $Map = typeof Map === "function" && Map.prototype ? Map : null; + var $Set = typeof Set === "function" && Set.prototype ? Set : null; + var exported; + if (!$Map) { + exported = function isMap(x) { + return false; + }; + } + var $mapHas = $Map ? Map.prototype.has : null; + var $setHas = $Set ? Set.prototype.has : null; + if (!exported && !$mapHas) { + exported = function isMap(x) { + return false; + }; + } + module2.exports = exported || function isMap(x) { + if (!x || typeof x !== "object") { + return false; + } + try { + $mapHas.call(x); + if ($setHas) { + try { + $setHas.call(x); + } catch (e) { + return true; + } + } + return x instanceof $Map; + } catch (e) { + } + return false; + }; + } +}); + +// node_modules/.pnpm/is-set@2.0.2/node_modules/is-set/index.js +var require_is_set = __commonJS({ + "node_modules/.pnpm/is-set@2.0.2/node_modules/is-set/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var $Map = typeof Map === "function" && Map.prototype ? Map : null; + var $Set = typeof Set === "function" && Set.prototype ? Set : null; + var exported; + if (!$Set) { + exported = function isSet(x) { + return false; + }; + } + var $mapHas = $Map ? Map.prototype.has : null; + var $setHas = $Set ? Set.prototype.has : null; + if (!exported && !$setHas) { + exported = function isSet(x) { + return false; + }; + } + module2.exports = exported || function isSet(x) { + if (!x || typeof x !== "object") { + return false; + } + try { + $setHas.call(x); + if ($mapHas) { + try { + $mapHas.call(x); + } catch (e) { + return true; + } + } + return x instanceof $Set; + } catch (e) { + } + return false; + }; + } +}); + +// node_modules/.pnpm/es-get-iterator@1.1.3/node_modules/es-get-iterator/index.js +var require_es_get_iterator = __commonJS({ + "node_modules/.pnpm/es-get-iterator@1.1.3/node_modules/es-get-iterator/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var isArguments = require_is_arguments(); + var getStopIterationIterator = require_stop_iteration_iterator(); + if (require_has_symbols()() || require_shams()()) { + $iterator = Symbol.iterator; + module2.exports = function getIterator3(iterable) { + if (iterable != null && typeof iterable[$iterator] !== "undefined") { + return iterable[$iterator](); + } + if (isArguments(iterable)) { + return Array.prototype[$iterator].call(iterable); + } + }; + } else { + isArray = require_isarray(); + isString = require_is_string(); + GetIntrinsic = require_get_intrinsic(); + $Map = GetIntrinsic("%Map%", true); + $Set = GetIntrinsic("%Set%", true); + callBound = require_callBound(); + $arrayPush = callBound("Array.prototype.push"); + $charCodeAt = callBound("String.prototype.charCodeAt"); + $stringSlice = callBound("String.prototype.slice"); + advanceStringIndex = function advanceStringIndex2(S, index2) { + var length = S.length; + if (index2 + 1 >= length) { + return index2 + 1; + } + var first2 = $charCodeAt(S, index2); + if (first2 < 55296 || first2 > 56319) { + return index2 + 1; + } + var second = $charCodeAt(S, index2 + 1); + if (second < 56320 || second > 57343) { + return index2 + 1; + } + return index2 + 2; + }; + getArrayIterator = function getArrayIterator2(arraylike) { + var i = 0; + return { + next: function next() { + var done = i >= arraylike.length; + var value; + if (!done) { + value = arraylike[i]; + i += 1; + } + return { + done, + value + }; + } + }; + }; + getNonCollectionIterator = function getNonCollectionIterator2(iterable, noPrimordialCollections) { + if (isArray(iterable) || isArguments(iterable)) { + return getArrayIterator(iterable); + } + if (isString(iterable)) { + var i = 0; + return { + next: function next() { + var nextIndex = advanceStringIndex(iterable, i); + var value = $stringSlice(iterable, i, nextIndex); + i = nextIndex; + return { + done: nextIndex > iterable.length, + value + }; + } + }; + } + if (noPrimordialCollections && typeof iterable["_es6-shim iterator_"] !== "undefined") { + return iterable["_es6-shim iterator_"](); + } + }; + if (!$Map && !$Set) { + module2.exports = function getIterator3(iterable) { + if (iterable != null) { + return getNonCollectionIterator(iterable, true); + } + }; + } else { + isMap = require_is_map(); + isSet = require_is_set(); + $mapForEach = callBound("Map.prototype.forEach", true); + $setForEach = callBound("Set.prototype.forEach", true); + if (typeof process === "undefined" || !process.versions || !process.versions.node) { + $mapIterator = callBound("Map.prototype.iterator", true); + $setIterator = callBound("Set.prototype.iterator", true); + } + $mapAtAtIterator = callBound("Map.prototype.@@iterator", true) || callBound("Map.prototype._es6-shim iterator_", true); + $setAtAtIterator = callBound("Set.prototype.@@iterator", true) || callBound("Set.prototype._es6-shim iterator_", true); + getCollectionIterator = function getCollectionIterator2(iterable) { + if (isMap(iterable)) { + if ($mapIterator) { + return getStopIterationIterator($mapIterator(iterable)); + } + if ($mapAtAtIterator) { + return $mapAtAtIterator(iterable); + } + if ($mapForEach) { + var entries = []; + $mapForEach(iterable, function(v, k) { + $arrayPush(entries, [k, v]); + }); + return getArrayIterator(entries); + } + } + if (isSet(iterable)) { + if ($setIterator) { + return getStopIterationIterator($setIterator(iterable)); + } + if ($setAtAtIterator) { + return $setAtAtIterator(iterable); + } + if ($setForEach) { + var values = []; + $setForEach(iterable, function(v) { + $arrayPush(values, v); + }); + return getArrayIterator(values); + } + } + }; + module2.exports = function getIterator3(iterable) { + return getCollectionIterator(iterable) || getNonCollectionIterator(iterable); + }; + } + } + var $iterator; + var isArray; + var isString; + var GetIntrinsic; + var $Map; + var $Set; + var callBound; + var $arrayPush; + var $charCodeAt; + var $stringSlice; + var advanceStringIndex; + var getArrayIterator; + var getNonCollectionIterator; + var isMap; + var isSet; + var $mapForEach; + var $setForEach; + var $mapIterator; + var $setIterator; + var $mapAtAtIterator; + var $setAtAtIterator; + var getCollectionIterator; + } +}); + +// node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/implementation.js +var require_implementation5 = __commonJS({ + "node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/implementation.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var numberIsNaN = function(value) { + return value !== value; + }; + module2.exports = function is(a, b) { + if (a === 0 && b === 0) { + return 1 / a === 1 / b; + } + if (a === b) { + return true; + } + if (numberIsNaN(a) && numberIsNaN(b)) { + return true; + } + return false; + }; + } +}); + +// node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/polyfill.js +var require_polyfill3 = __commonJS({ + "node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/polyfill.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var implementation = require_implementation5(); + module2.exports = function getPolyfill() { + return typeof Object.is === "function" ? Object.is : implementation; + }; + } +}); + +// node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/shim.js +var require_shim3 = __commonJS({ + "node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/shim.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var getPolyfill = require_polyfill3(); + var define2 = require_define_properties(); + module2.exports = function shimObjectIs() { + var polyfill = getPolyfill(); + define2(Object, { is: polyfill }, { + is: function testObjectIs() { + return Object.is !== polyfill; + } + }); + return polyfill; + }; + } +}); + +// node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/index.js +var require_object_is = __commonJS({ + "node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var define2 = require_define_properties(); + var callBind = require_call_bind(); + var implementation = require_implementation5(); + var getPolyfill = require_polyfill3(); + var shim = require_shim3(); + var polyfill = callBind(getPolyfill(), Object); + define2(polyfill, { + getPolyfill, + implementation, + shim + }); + module2.exports = polyfill; + } +}); + +// node_modules/.pnpm/is-callable@1.2.7/node_modules/is-callable/index.js +var require_is_callable = __commonJS({ + "node_modules/.pnpm/is-callable@1.2.7/node_modules/is-callable/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var fnToStr = Function.prototype.toString; + var reflectApply = typeof Reflect === "object" && Reflect !== null && Reflect.apply; + var badArrayLike; + var isCallableMarker; + if (typeof reflectApply === "function" && typeof Object.defineProperty === "function") { + try { + badArrayLike = Object.defineProperty({}, "length", { + get: function() { + throw isCallableMarker; + } + }); + isCallableMarker = {}; + reflectApply(function() { + throw 42; + }, null, badArrayLike); + } catch (_) { + if (_ !== isCallableMarker) { + reflectApply = null; + } + } + } else { + reflectApply = null; + } + var constructorRegex = /^\s*class\b/; + var isES6ClassFn = function isES6ClassFunction(value) { + try { + var fnStr = fnToStr.call(value); + return constructorRegex.test(fnStr); + } catch (e) { + return false; + } + }; + var tryFunctionObject = function tryFunctionToStr(value) { + try { + if (isES6ClassFn(value)) { + return false; + } + fnToStr.call(value); + return true; + } catch (e) { + return false; + } + }; + var toStr = Object.prototype.toString; + var objectClass = "[object Object]"; + var fnClass = "[object Function]"; + var genClass = "[object GeneratorFunction]"; + var ddaClass = "[object HTMLAllCollection]"; + var ddaClass2 = "[object HTML document.all class]"; + var ddaClass3 = "[object HTMLCollection]"; + var hasToStringTag = typeof Symbol === "function" && !!Symbol.toStringTag; + var isIE68 = !(0 in [,]); + var isDDA = function isDocumentDotAll() { + return false; + }; + if (typeof document === "object") { + all = document.all; + if (toStr.call(all) === toStr.call(document.all)) { + isDDA = function isDocumentDotAll(value) { + if ((isIE68 || !value) && (typeof value === "undefined" || typeof value === "object")) { + try { + var str = toStr.call(value); + return (str === ddaClass || str === ddaClass2 || str === ddaClass3 || str === objectClass) && value("") == null; + } catch (e) { + } + } + return false; + }; + } + } + var all; + module2.exports = reflectApply ? function isCallable(value) { + if (isDDA(value)) { + return true; + } + if (!value) { + return false; + } + if (typeof value !== "function" && typeof value !== "object") { + return false; + } + try { + reflectApply(value, null, badArrayLike); + } catch (e) { + if (e !== isCallableMarker) { + return false; + } + } + return !isES6ClassFn(value) && tryFunctionObject(value); + } : function isCallable(value) { + if (isDDA(value)) { + return true; + } + if (!value) { + return false; + } + if (typeof value !== "function" && typeof value !== "object") { + return false; + } + if (hasToStringTag) { + return tryFunctionObject(value); + } + if (isES6ClassFn(value)) { + return false; + } + var strClass = toStr.call(value); + if (strClass !== fnClass && strClass !== genClass && !/^\[object HTML/.test(strClass)) { + return false; + } + return tryFunctionObject(value); + }; + } +}); + +// node_modules/.pnpm/for-each@0.3.3/node_modules/for-each/index.js +var require_for_each = __commonJS({ + "node_modules/.pnpm/for-each@0.3.3/node_modules/for-each/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var isCallable = require_is_callable(); + var toStr = Object.prototype.toString; + var hasOwnProperty = Object.prototype.hasOwnProperty; + var forEachArray = function forEachArray2(array, iterator, receiver) { + for (var i = 0, len = array.length; i < len; i++) { + if (hasOwnProperty.call(array, i)) { + if (receiver == null) { + iterator(array[i], i, array); + } else { + iterator.call(receiver, array[i], i, array); + } + } + } + }; + var forEachString = function forEachString2(string, iterator, receiver) { + for (var i = 0, len = string.length; i < len; i++) { + if (receiver == null) { + iterator(string.charAt(i), i, string); + } else { + iterator.call(receiver, string.charAt(i), i, string); + } + } + }; + var forEachObject = function forEachObject2(object, iterator, receiver) { + for (var k in object) { + if (hasOwnProperty.call(object, k)) { + if (receiver == null) { + iterator(object[k], k, object); + } else { + iterator.call(receiver, object[k], k, object); + } + } + } + }; + var forEach2 = function forEach3(list, iterator, thisArg) { + if (!isCallable(iterator)) { + throw new TypeError("iterator must be a function"); + } + var receiver; + if (arguments.length >= 3) { + receiver = thisArg; + } + if (toStr.call(list) === "[object Array]") { + forEachArray(list, iterator, receiver); + } else if (typeof list === "string") { + forEachString(list, iterator, receiver); + } else { + forEachObject(list, iterator, receiver); + } + }; + module2.exports = forEach2; + } +}); + +// node_modules/.pnpm/available-typed-arrays@1.0.5/node_modules/available-typed-arrays/index.js +var require_available_typed_arrays = __commonJS({ + "node_modules/.pnpm/available-typed-arrays@1.0.5/node_modules/available-typed-arrays/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var possibleNames = [ + "BigInt64Array", + "BigUint64Array", + "Float32Array", + "Float64Array", + "Int16Array", + "Int32Array", + "Int8Array", + "Uint16Array", + "Uint32Array", + "Uint8Array", + "Uint8ClampedArray" + ]; + var g = typeof globalThis === "undefined" ? global : globalThis; + module2.exports = function availableTypedArrays() { + var out = []; + for (var i = 0; i < possibleNames.length; i++) { + if (typeof g[possibleNames[i]] === "function") { + out[out.length] = possibleNames[i]; + } + } + return out; + }; + } +}); + +// node_modules/.pnpm/gopd@1.0.1/node_modules/gopd/index.js +var require_gopd = __commonJS({ + "node_modules/.pnpm/gopd@1.0.1/node_modules/gopd/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var GetIntrinsic = require_get_intrinsic(); + var $gOPD = GetIntrinsic("%Object.getOwnPropertyDescriptor%", true); + if ($gOPD) { + try { + $gOPD([], "length"); + } catch (e) { + $gOPD = null; + } + } + module2.exports = $gOPD; + } +}); + +// node_modules/.pnpm/is-typed-array@1.1.10/node_modules/is-typed-array/index.js +var require_is_typed_array = __commonJS({ + "node_modules/.pnpm/is-typed-array@1.1.10/node_modules/is-typed-array/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var forEach2 = require_for_each(); + var availableTypedArrays = require_available_typed_arrays(); + var callBound = require_callBound(); + var $toString = callBound("Object.prototype.toString"); + var hasToStringTag = require_shams2()(); + var gOPD = require_gopd(); + var g = typeof globalThis === "undefined" ? global : globalThis; + var typedArrays = availableTypedArrays(); + var $indexOf = callBound("Array.prototype.indexOf", true) || function indexOf(array, value) { + for (var i = 0; i < array.length; i += 1) { + if (array[i] === value) { + return i; + } + } + return -1; + }; + var $slice = callBound("String.prototype.slice"); + var toStrTags = {}; + var getPrototypeOf = Object.getPrototypeOf; + if (hasToStringTag && gOPD && getPrototypeOf) { + forEach2(typedArrays, function(typedArray) { + var arr = new g[typedArray](); + if (Symbol.toStringTag in arr) { + var proto = getPrototypeOf(arr); + var descriptor = gOPD(proto, Symbol.toStringTag); + if (!descriptor) { + var superProto = getPrototypeOf(proto); + descriptor = gOPD(superProto, Symbol.toStringTag); + } + toStrTags[typedArray] = descriptor.get; + } + }); + } + var tryTypedArrays = function tryAllTypedArrays(value) { + var anyTrue = false; + forEach2(toStrTags, function(getter, typedArray) { + if (!anyTrue) { + try { + anyTrue = getter.call(value) === typedArray; + } catch (e) { + } + } + }); + return anyTrue; + }; + module2.exports = function isTypedArray(value) { + if (!value || typeof value !== "object") { + return false; + } + if (!hasToStringTag || !(Symbol.toStringTag in value)) { + var tag2 = $slice($toString(value), 8, -1); + return $indexOf(typedArrays, tag2) > -1; + } + if (!gOPD) { + return false; + } + return tryTypedArrays(value); + }; + } +}); + +// node_modules/.pnpm/is-array-buffer@3.0.2/node_modules/is-array-buffer/index.js +var require_is_array_buffer = __commonJS({ + "node_modules/.pnpm/is-array-buffer@3.0.2/node_modules/is-array-buffer/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var callBind = require_call_bind(); + var callBound = require_callBound(); + var GetIntrinsic = require_get_intrinsic(); + var isTypedArray = require_is_typed_array(); + var $ArrayBuffer = GetIntrinsic("ArrayBuffer", true); + var $Float32Array = GetIntrinsic("Float32Array", true); + var $byteLength = callBound("ArrayBuffer.prototype.byteLength", true); + var abSlice = $ArrayBuffer && !$byteLength && new $ArrayBuffer().slice; + var $abSlice = abSlice && callBind(abSlice); + module2.exports = $byteLength || $abSlice ? function isArrayBuffer(obj) { + if (!obj || typeof obj !== "object") { + return false; + } + try { + if ($byteLength) { + $byteLength(obj); + } else { + $abSlice(obj, 0); + } + return true; + } catch (e) { + return false; + } + } : $Float32Array ? function IsArrayBuffer(obj) { + try { + return new $Float32Array(obj).buffer === obj && !isTypedArray(obj); + } catch (e) { + return typeof obj === "object" && e.name === "RangeError"; + } + } : function isArrayBuffer(obj) { + return false; + }; + } +}); + +// node_modules/.pnpm/is-date-object@1.0.5/node_modules/is-date-object/index.js +var require_is_date_object = __commonJS({ + "node_modules/.pnpm/is-date-object@1.0.5/node_modules/is-date-object/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var getDay = Date.prototype.getDay; + var tryDateObject = function tryDateGetDayCall(value) { + try { + getDay.call(value); + return true; + } catch (e) { + return false; + } + }; + var toStr = Object.prototype.toString; + var dateClass = "[object Date]"; + var hasToStringTag = require_shams2()(); + module2.exports = function isDateObject(value) { + if (typeof value !== "object" || value === null) { + return false; + } + return hasToStringTag ? tryDateObject(value) : toStr.call(value) === dateClass; + }; + } +}); + +// node_modules/.pnpm/is-regex@1.1.4/node_modules/is-regex/index.js +var require_is_regex = __commonJS({ + "node_modules/.pnpm/is-regex@1.1.4/node_modules/is-regex/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var callBound = require_callBound(); + var hasToStringTag = require_shams2()(); + var has; + var $exec; + var isRegexMarker; + var badStringifier; + if (hasToStringTag) { + has = callBound("Object.prototype.hasOwnProperty"); + $exec = callBound("RegExp.prototype.exec"); + isRegexMarker = {}; + throwRegexMarker = function() { + throw isRegexMarker; + }; + badStringifier = { + toString: throwRegexMarker, + valueOf: throwRegexMarker + }; + if (typeof Symbol.toPrimitive === "symbol") { + badStringifier[Symbol.toPrimitive] = throwRegexMarker; + } + } + var throwRegexMarker; + var $toString = callBound("Object.prototype.toString"); + var gOPD = Object.getOwnPropertyDescriptor; + var regexClass = "[object RegExp]"; + module2.exports = hasToStringTag ? function isRegex(value) { + if (!value || typeof value !== "object") { + return false; + } + var descriptor = gOPD(value, "lastIndex"); + var hasLastIndexDataProperty = descriptor && has(descriptor, "value"); + if (!hasLastIndexDataProperty) { + return false; + } + try { + $exec(value, badStringifier); + } catch (e) { + return e === isRegexMarker; + } + } : function isRegex(value) { + if (!value || typeof value !== "object" && typeof value !== "function") { + return false; + } + return $toString(value) === regexClass; + }; + } +}); + +// node_modules/.pnpm/is-shared-array-buffer@1.0.2/node_modules/is-shared-array-buffer/index.js +var require_is_shared_array_buffer = __commonJS({ + "node_modules/.pnpm/is-shared-array-buffer@1.0.2/node_modules/is-shared-array-buffer/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var callBound = require_callBound(); + var $byteLength = callBound("SharedArrayBuffer.prototype.byteLength", true); + module2.exports = $byteLength ? function isSharedArrayBuffer(obj) { + if (!obj || typeof obj !== "object") { + return false; + } + try { + $byteLength(obj); + return true; + } catch (e) { + return false; + } + } : function isSharedArrayBuffer(obj) { + return false; + }; + } +}); + +// node_modules/.pnpm/is-number-object@1.0.7/node_modules/is-number-object/index.js +var require_is_number_object = __commonJS({ + "node_modules/.pnpm/is-number-object@1.0.7/node_modules/is-number-object/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var numToStr = Number.prototype.toString; + var tryNumberObject = function tryNumberObject2(value) { + try { + numToStr.call(value); + return true; + } catch (e) { + return false; + } + }; + var toStr = Object.prototype.toString; + var numClass = "[object Number]"; + var hasToStringTag = require_shams2()(); + module2.exports = function isNumberObject(value) { + if (typeof value === "number") { + return true; + } + if (typeof value !== "object") { + return false; + } + return hasToStringTag ? tryNumberObject(value) : toStr.call(value) === numClass; + }; + } +}); + +// node_modules/.pnpm/is-boolean-object@1.1.2/node_modules/is-boolean-object/index.js +var require_is_boolean_object = __commonJS({ + "node_modules/.pnpm/is-boolean-object@1.1.2/node_modules/is-boolean-object/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var callBound = require_callBound(); + var $boolToStr = callBound("Boolean.prototype.toString"); + var $toString = callBound("Object.prototype.toString"); + var tryBooleanObject = function booleanBrandCheck(value) { + try { + $boolToStr(value); + return true; + } catch (e) { + return false; + } + }; + var boolClass = "[object Boolean]"; + var hasToStringTag = require_shams2()(); + module2.exports = function isBoolean(value) { + if (typeof value === "boolean") { + return true; + } + if (value === null || typeof value !== "object") { + return false; + } + return hasToStringTag && Symbol.toStringTag in value ? tryBooleanObject(value) : $toString(value) === boolClass; + }; + } +}); + +// node_modules/.pnpm/is-symbol@1.0.4/node_modules/is-symbol/index.js +var require_is_symbol = __commonJS({ + "node_modules/.pnpm/is-symbol@1.0.4/node_modules/is-symbol/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var toStr = Object.prototype.toString; + var hasSymbols = require_has_symbols()(); + if (hasSymbols) { + symToStr = Symbol.prototype.toString; + symStringRegex = /^Symbol\(.*\)$/; + isSymbolObject = function isRealSymbolObject(value) { + if (typeof value.valueOf() !== "symbol") { + return false; + } + return symStringRegex.test(symToStr.call(value)); + }; + module2.exports = function isSymbol(value) { + if (typeof value === "symbol") { + return true; + } + if (toStr.call(value) !== "[object Symbol]") { + return false; + } + try { + return isSymbolObject(value); + } catch (e) { + return false; + } + }; + } else { + module2.exports = function isSymbol(value) { + return false; + }; + } + var symToStr; + var symStringRegex; + var isSymbolObject; + } +}); + +// node_modules/.pnpm/has-bigints@1.0.2/node_modules/has-bigints/index.js +var require_has_bigints = __commonJS({ + "node_modules/.pnpm/has-bigints@1.0.2/node_modules/has-bigints/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var $BigInt = typeof BigInt !== "undefined" && BigInt; + module2.exports = function hasNativeBigInts() { + return typeof $BigInt === "function" && typeof BigInt === "function" && typeof $BigInt(42) === "bigint" && typeof BigInt(42) === "bigint"; + }; + } +}); + +// node_modules/.pnpm/is-bigint@1.0.4/node_modules/is-bigint/index.js +var require_is_bigint = __commonJS({ + "node_modules/.pnpm/is-bigint@1.0.4/node_modules/is-bigint/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var hasBigInts = require_has_bigints()(); + if (hasBigInts) { + bigIntValueOf = BigInt.prototype.valueOf; + tryBigInt = function tryBigIntObject(value) { + try { + bigIntValueOf.call(value); + return true; + } catch (e) { + } + return false; + }; + module2.exports = function isBigInt(value) { + if (value === null || typeof value === "undefined" || typeof value === "boolean" || typeof value === "string" || typeof value === "number" || typeof value === "symbol" || typeof value === "function") { + return false; + } + if (typeof value === "bigint") { + return true; + } + return tryBigInt(value); + }; + } else { + module2.exports = function isBigInt(value) { + return false; + }; + } + var bigIntValueOf; + var tryBigInt; + } +}); + +// node_modules/.pnpm/which-boxed-primitive@1.0.2/node_modules/which-boxed-primitive/index.js +var require_which_boxed_primitive = __commonJS({ + "node_modules/.pnpm/which-boxed-primitive@1.0.2/node_modules/which-boxed-primitive/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var isString = require_is_string(); + var isNumber = require_is_number_object(); + var isBoolean = require_is_boolean_object(); + var isSymbol = require_is_symbol(); + var isBigInt = require_is_bigint(); + module2.exports = function whichBoxedPrimitive(value) { + if (value == null || typeof value !== "object" && typeof value !== "function") { + return null; + } + if (isString(value)) { + return "String"; + } + if (isNumber(value)) { + return "Number"; + } + if (isBoolean(value)) { + return "Boolean"; + } + if (isSymbol(value)) { + return "Symbol"; + } + if (isBigInt(value)) { + return "BigInt"; + } + }; + } +}); + +// node_modules/.pnpm/is-weakmap@2.0.1/node_modules/is-weakmap/index.js +var require_is_weakmap = __commonJS({ + "node_modules/.pnpm/is-weakmap@2.0.1/node_modules/is-weakmap/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var $WeakMap = typeof WeakMap === "function" && WeakMap.prototype ? WeakMap : null; + var $WeakSet = typeof WeakSet === "function" && WeakSet.prototype ? WeakSet : null; + var exported; + if (!$WeakMap) { + exported = function isWeakMap(x) { + return false; + }; + } + var $mapHas = $WeakMap ? $WeakMap.prototype.has : null; + var $setHas = $WeakSet ? $WeakSet.prototype.has : null; + if (!exported && !$mapHas) { + exported = function isWeakMap(x) { + return false; + }; + } + module2.exports = exported || function isWeakMap(x) { + if (!x || typeof x !== "object") { + return false; + } + try { + $mapHas.call(x, $mapHas); + if ($setHas) { + try { + $setHas.call(x, $setHas); + } catch (e) { + return true; + } + } + return x instanceof $WeakMap; + } catch (e) { + } + return false; + }; + } +}); + +// node_modules/.pnpm/is-weakset@2.0.2/node_modules/is-weakset/index.js +var require_is_weakset = __commonJS({ + "node_modules/.pnpm/is-weakset@2.0.2/node_modules/is-weakset/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var GetIntrinsic = require_get_intrinsic(); + var callBound = require_callBound(); + var $WeakSet = GetIntrinsic("%WeakSet%", true); + var $setHas = callBound("WeakSet.prototype.has", true); + if ($setHas) { + $mapHas = callBound("WeakMap.prototype.has", true); + module2.exports = function isWeakSet(x) { + if (!x || typeof x !== "object") { + return false; + } + try { + $setHas(x, $setHas); + if ($mapHas) { + try { + $mapHas(x, $mapHas); + } catch (e) { + return true; + } + } + return x instanceof $WeakSet; + } catch (e) { + } + return false; + }; + } else { + module2.exports = function isWeakSet(x) { + return false; + }; + } + var $mapHas; + } +}); + +// node_modules/.pnpm/which-collection@1.0.1/node_modules/which-collection/index.js +var require_which_collection = __commonJS({ + "node_modules/.pnpm/which-collection@1.0.1/node_modules/which-collection/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var isMap = require_is_map(); + var isSet = require_is_set(); + var isWeakMap = require_is_weakmap(); + var isWeakSet = require_is_weakset(); + module2.exports = function whichCollection(value) { + if (value && typeof value === "object") { + if (isMap(value)) { + return "Map"; + } + if (isSet(value)) { + return "Set"; + } + if (isWeakMap(value)) { + return "WeakMap"; + } + if (isWeakSet(value)) { + return "WeakSet"; + } + } + return false; + }; + } +}); + +// node_modules/.pnpm/which-typed-array@1.1.9/node_modules/which-typed-array/index.js +var require_which_typed_array = __commonJS({ + "node_modules/.pnpm/which-typed-array@1.1.9/node_modules/which-typed-array/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var forEach2 = require_for_each(); + var availableTypedArrays = require_available_typed_arrays(); + var callBound = require_callBound(); + var gOPD = require_gopd(); + var $toString = callBound("Object.prototype.toString"); + var hasToStringTag = require_shams2()(); + var g = typeof globalThis === "undefined" ? global : globalThis; + var typedArrays = availableTypedArrays(); + var $slice = callBound("String.prototype.slice"); + var toStrTags = {}; + var getPrototypeOf = Object.getPrototypeOf; + if (hasToStringTag && gOPD && getPrototypeOf) { + forEach2(typedArrays, function(typedArray) { + if (typeof g[typedArray] === "function") { + var arr = new g[typedArray](); + if (Symbol.toStringTag in arr) { + var proto = getPrototypeOf(arr); + var descriptor = gOPD(proto, Symbol.toStringTag); + if (!descriptor) { + var superProto = getPrototypeOf(proto); + descriptor = gOPD(superProto, Symbol.toStringTag); + } + toStrTags[typedArray] = descriptor.get; + } + } + }); + } + var tryTypedArrays = function tryAllTypedArrays(value) { + var foundName = false; + forEach2(toStrTags, function(getter, typedArray) { + if (!foundName) { + try { + var name = getter.call(value); + if (name === typedArray) { + foundName = name; + } + } catch (e) { + } + } + }); + return foundName; + }; + var isTypedArray = require_is_typed_array(); + module2.exports = function whichTypedArray(value) { + if (!isTypedArray(value)) { + return false; + } + if (!hasToStringTag || !(Symbol.toStringTag in value)) { + return $slice($toString(value), 8, -1); + } + return tryTypedArrays(value); + }; + } +}); + +// node_modules/.pnpm/array-buffer-byte-length@1.0.0/node_modules/array-buffer-byte-length/index.js +var require_array_buffer_byte_length = __commonJS({ + "node_modules/.pnpm/array-buffer-byte-length@1.0.0/node_modules/array-buffer-byte-length/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var callBound = require_callBound(); + var $byteLength = callBound("ArrayBuffer.prototype.byteLength", true); + var isArrayBuffer = require_is_array_buffer(); + module2.exports = function byteLength(ab) { + if (!isArrayBuffer(ab)) { + return NaN; + } + return $byteLength ? $byteLength(ab) : ab.byteLength; + }; + } +}); + +// node_modules/.pnpm/deep-equal@2.2.1/node_modules/deep-equal/index.js +var require_deep_equal = __commonJS({ + "node_modules/.pnpm/deep-equal@2.2.1/node_modules/deep-equal/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var assign2 = require_object(); + var callBound = require_callBound(); + var flags = require_regexp_prototype(); + var GetIntrinsic = require_get_intrinsic(); + var getIterator3 = require_es_get_iterator(); + var getSideChannel = require_side_channel(); + var is = require_object_is(); + var isArguments = require_is_arguments(); + var isArray = require_isarray(); + var isArrayBuffer = require_is_array_buffer(); + var isDate = require_is_date_object(); + var isRegex = require_is_regex(); + var isSharedArrayBuffer = require_is_shared_array_buffer(); + var objectKeys = require_object_keys(); + var whichBoxedPrimitive = require_which_boxed_primitive(); + var whichCollection = require_which_collection(); + var whichTypedArray = require_which_typed_array(); + var byteLength = require_array_buffer_byte_length(); + var sabByteLength = callBound("SharedArrayBuffer.prototype.byteLength", true); + var $getTime = callBound("Date.prototype.getTime"); + var gPO = Object.getPrototypeOf; + var $objToString = callBound("Object.prototype.toString"); + var $Set = GetIntrinsic("%Set%", true); + var $mapHas = callBound("Map.prototype.has", true); + var $mapGet = callBound("Map.prototype.get", true); + var $mapSize = callBound("Map.prototype.size", true); + var $setAdd = callBound("Set.prototype.add", true); + var $setDelete = callBound("Set.prototype.delete", true); + var $setHas = callBound("Set.prototype.has", true); + var $setSize = callBound("Set.prototype.size", true); + function setHasEqualElement(set, val1, opts, channel) { + var i = getIterator3(set); + var result; + while ((result = i.next()) && !result.done) { + if (internalDeepEqual(val1, result.value, opts, channel)) { + $setDelete(set, result.value); + return true; + } + } + return false; + } + function findLooseMatchingPrimitives(prim) { + if (typeof prim === "undefined") { + return null; + } + if (typeof prim === "object") { + return void 0; + } + if (typeof prim === "symbol") { + return false; + } + if (typeof prim === "string" || typeof prim === "number") { + return +prim === +prim; + } + return true; + } + function mapMightHaveLoosePrim(a, b, prim, item, opts, channel) { + var altValue = findLooseMatchingPrimitives(prim); + if (altValue != null) { + return altValue; + } + var curB = $mapGet(b, altValue); + var looseOpts = assign2({}, opts, { strict: false }); + if (typeof curB === "undefined" && !$mapHas(b, altValue) || !internalDeepEqual(item, curB, looseOpts, channel)) { + return false; + } + return !$mapHas(a, altValue) && internalDeepEqual(item, curB, looseOpts, channel); + } + function setMightHaveLoosePrim(a, b, prim) { + var altValue = findLooseMatchingPrimitives(prim); + if (altValue != null) { + return altValue; + } + return $setHas(b, altValue) && !$setHas(a, altValue); + } + function mapHasEqualEntry(set, map, key1, item1, opts, channel) { + var i = getIterator3(set); + var result; + var key2; + while ((result = i.next()) && !result.done) { + key2 = result.value; + if ( + // eslint-disable-next-line no-use-before-define + internalDeepEqual(key1, key2, opts, channel) && internalDeepEqual(item1, $mapGet(map, key2), opts, channel) + ) { + $setDelete(set, key2); + return true; + } + } + return false; + } + function internalDeepEqual(actual, expected, options, channel) { + var opts = options || {}; + if (opts.strict ? is(actual, expected) : actual === expected) { + return true; + } + var actualBoxed = whichBoxedPrimitive(actual); + var expectedBoxed = whichBoxedPrimitive(expected); + if (actualBoxed !== expectedBoxed) { + return false; + } + if (!actual || !expected || typeof actual !== "object" && typeof expected !== "object") { + return opts.strict ? is(actual, expected) : actual == expected; + } + var hasActual = channel.has(actual); + var hasExpected = channel.has(expected); + var sentinel; + if (hasActual && hasExpected) { + if (channel.get(actual) === channel.get(expected)) { + return true; + } + } else { + sentinel = {}; + } + if (!hasActual) { + channel.set(actual, sentinel); + } + if (!hasExpected) { + channel.set(expected, sentinel); + } + return objEquiv(actual, expected, opts, channel); + } + function isBuffer(x) { + if (!x || typeof x !== "object" || typeof x.length !== "number") { + return false; + } + if (typeof x.copy !== "function" || typeof x.slice !== "function") { + return false; + } + if (x.length > 0 && typeof x[0] !== "number") { + return false; + } + return !!(x.constructor && x.constructor.isBuffer && x.constructor.isBuffer(x)); + } + function setEquiv(a, b, opts, channel) { + if ($setSize(a) !== $setSize(b)) { + return false; + } + var iA = getIterator3(a); + var iB = getIterator3(b); + var resultA; + var resultB; + var set; + while ((resultA = iA.next()) && !resultA.done) { + if (resultA.value && typeof resultA.value === "object") { + if (!set) { + set = new $Set(); + } + $setAdd(set, resultA.value); + } else if (!$setHas(b, resultA.value)) { + if (opts.strict) { + return false; + } + if (!setMightHaveLoosePrim(a, b, resultA.value)) { + return false; + } + if (!set) { + set = new $Set(); + } + $setAdd(set, resultA.value); + } + } + if (set) { + while ((resultB = iB.next()) && !resultB.done) { + if (resultB.value && typeof resultB.value === "object") { + if (!setHasEqualElement(set, resultB.value, opts.strict, channel)) { + return false; + } + } else if (!opts.strict && !$setHas(a, resultB.value) && !setHasEqualElement(set, resultB.value, opts.strict, channel)) { + return false; + } + } + return $setSize(set) === 0; + } + return true; + } + function mapEquiv(a, b, opts, channel) { + if ($mapSize(a) !== $mapSize(b)) { + return false; + } + var iA = getIterator3(a); + var iB = getIterator3(b); + var resultA; + var resultB; + var set; + var key2; + var item1; + var item2; + while ((resultA = iA.next()) && !resultA.done) { + key2 = resultA.value[0]; + item1 = resultA.value[1]; + if (key2 && typeof key2 === "object") { + if (!set) { + set = new $Set(); + } + $setAdd(set, key2); + } else { + item2 = $mapGet(b, key2); + if (typeof item2 === "undefined" && !$mapHas(b, key2) || !internalDeepEqual(item1, item2, opts, channel)) { + if (opts.strict) { + return false; + } + if (!mapMightHaveLoosePrim(a, b, key2, item1, opts, channel)) { + return false; + } + if (!set) { + set = new $Set(); + } + $setAdd(set, key2); + } + } + } + if (set) { + while ((resultB = iB.next()) && !resultB.done) { + key2 = resultB.value[0]; + item2 = resultB.value[1]; + if (key2 && typeof key2 === "object") { + if (!mapHasEqualEntry(set, a, key2, item2, opts, channel)) { + return false; + } + } else if (!opts.strict && (!a.has(key2) || !internalDeepEqual($mapGet(a, key2), item2, opts, channel)) && !mapHasEqualEntry(set, a, key2, item2, assign2({}, opts, { strict: false }), channel)) { + return false; + } + } + return $setSize(set) === 0; + } + return true; + } + function objEquiv(a, b, opts, channel) { + var i, key2; + if (typeof a !== typeof b) { + return false; + } + if (a == null || b == null) { + return false; + } + if ($objToString(a) !== $objToString(b)) { + return false; + } + if (isArguments(a) !== isArguments(b)) { + return false; + } + var aIsArray = isArray(a); + var bIsArray = isArray(b); + if (aIsArray !== bIsArray) { + return false; + } + var aIsError = a instanceof Error; + var bIsError = b instanceof Error; + if (aIsError !== bIsError) { + return false; + } + if (aIsError || bIsError) { + if (a.name !== b.name || a.message !== b.message) { + return false; + } + } + var aIsRegex = isRegex(a); + var bIsRegex = isRegex(b); + if (aIsRegex !== bIsRegex) { + return false; + } + if ((aIsRegex || bIsRegex) && (a.source !== b.source || flags(a) !== flags(b))) { + return false; + } + var aIsDate = isDate(a); + var bIsDate = isDate(b); + if (aIsDate !== bIsDate) { + return false; + } + if (aIsDate || bIsDate) { + if ($getTime(a) !== $getTime(b)) { + return false; + } + } + if (opts.strict && gPO && gPO(a) !== gPO(b)) { + return false; + } + var aWhich = whichTypedArray(a); + var bWhich = whichTypedArray(b); + if ((aWhich || bWhich) && aWhich !== bWhich) { + return false; + } + var aIsBuffer = isBuffer(a); + var bIsBuffer = isBuffer(b); + if (aIsBuffer !== bIsBuffer) { + return false; + } + if (aIsBuffer || bIsBuffer) { + if (a.length !== b.length) { + return false; + } + for (i = 0; i < a.length; i++) { + if (a[i] !== b[i]) { + return false; + } + } + return true; + } + var aIsArrayBuffer = isArrayBuffer(a); + var bIsArrayBuffer = isArrayBuffer(b); + if (aIsArrayBuffer !== bIsArrayBuffer) { + return false; + } + if (aIsArrayBuffer || bIsArrayBuffer) { + if (byteLength(a) !== byteLength(b)) { + return false; + } + return typeof Uint8Array === "function" && internalDeepEqual(new Uint8Array(a), new Uint8Array(b), opts, channel); + } + var aIsSAB = isSharedArrayBuffer(a); + var bIsSAB = isSharedArrayBuffer(b); + if (aIsSAB !== bIsSAB) { + return false; + } + if (aIsSAB || bIsSAB) { + if (sabByteLength(a) !== sabByteLength(b)) { + return false; + } + return typeof Uint8Array === "function" && internalDeepEqual(new Uint8Array(a), new Uint8Array(b), opts, channel); + } + if (typeof a !== typeof b) { + return false; + } + var ka = objectKeys(a); + var kb = objectKeys(b); + if (ka.length !== kb.length) { + return false; + } + ka.sort(); + kb.sort(); + for (i = ka.length - 1; i >= 0; i--) { + if (ka[i] != kb[i]) { + return false; + } + } + for (i = ka.length - 1; i >= 0; i--) { + key2 = ka[i]; + if (!internalDeepEqual(a[key2], b[key2], opts, channel)) { + return false; + } + } + var aCollection = whichCollection(a); + var bCollection = whichCollection(b); + if (aCollection !== bCollection) { + return false; + } + if (aCollection === "Set" || bCollection === "Set") { + return setEquiv(a, b, opts, channel); + } + if (aCollection === "Map") { + return mapEquiv(a, b, opts, channel); + } + return true; + } + module2.exports = function deepEqual2(a, b, opts) { + return internalDeepEqual(a, b, opts, getSideChannel()); + }; + } +}); + +// node_modules/.pnpm/js-sha256@0.9.0/node_modules/js-sha256/src/sha256.js +var require_sha256 = __commonJS({ + "node_modules/.pnpm/js-sha256@0.9.0/node_modules/js-sha256/src/sha256.js"(exports, module) { + init_polyfill_buffer(); + (function() { + "use strict"; + var ERROR = "input is invalid type"; + var WINDOW = typeof window === "object"; + var root = WINDOW ? window : {}; + if (root.JS_SHA256_NO_WINDOW) { + WINDOW = false; + } + var WEB_WORKER = !WINDOW && typeof self === "object"; + var NODE_JS = !root.JS_SHA256_NO_NODE_JS && typeof process === "object" && process.versions && process.versions.node; + if (NODE_JS) { + root = global; + } else if (WEB_WORKER) { + root = self; + } + var COMMON_JS = !root.JS_SHA256_NO_COMMON_JS && typeof module === "object" && module.exports; + var AMD = typeof define === "function" && define.amd; + var ARRAY_BUFFER = !root.JS_SHA256_NO_ARRAY_BUFFER && typeof ArrayBuffer !== "undefined"; + var HEX_CHARS = "0123456789abcdef".split(""); + var EXTRA = [-2147483648, 8388608, 32768, 128]; + var SHIFT = [24, 16, 8, 0]; + var K = [ + 1116352408, + 1899447441, + 3049323471, + 3921009573, + 961987163, + 1508970993, + 2453635748, + 2870763221, + 3624381080, + 310598401, + 607225278, + 1426881987, + 1925078388, + 2162078206, + 2614888103, + 3248222580, + 3835390401, + 4022224774, + 264347078, + 604807628, + 770255983, + 1249150122, + 1555081692, + 1996064986, + 2554220882, + 2821834349, + 2952996808, + 3210313671, + 3336571891, + 3584528711, + 113926993, + 338241895, + 666307205, + 773529912, + 1294757372, + 1396182291, + 1695183700, + 1986661051, + 2177026350, + 2456956037, + 2730485921, + 2820302411, + 3259730800, + 3345764771, + 3516065817, + 3600352804, + 4094571909, + 275423344, + 430227734, + 506948616, + 659060556, + 883997877, + 958139571, + 1322822218, + 1537002063, + 1747873779, + 1955562222, + 2024104815, + 2227730452, + 2361852424, + 2428436474, + 2756734187, + 3204031479, + 3329325298 + ]; + var OUTPUT_TYPES = ["hex", "array", "digest", "arrayBuffer"]; + var blocks = []; + if (root.JS_SHA256_NO_NODE_JS || !Array.isArray) { + Array.isArray = function(obj) { + return Object.prototype.toString.call(obj) === "[object Array]"; + }; + } + if (ARRAY_BUFFER && (root.JS_SHA256_NO_ARRAY_BUFFER_IS_VIEW || !ArrayBuffer.isView)) { + ArrayBuffer.isView = function(obj) { + return typeof obj === "object" && obj.buffer && obj.buffer.constructor === ArrayBuffer; + }; + } + var createOutputMethod = function(outputType, is2242) { + return function(message) { + return new Sha256(is2242, true).update(message)[outputType](); + }; + }; + var createMethod = function(is2242) { + var method2 = createOutputMethod("hex", is2242); + if (NODE_JS) { + method2 = nodeWrap(method2, is2242); + } + method2.create = function() { + return new Sha256(is2242); + }; + method2.update = function(message) { + return method2.create().update(message); + }; + for (var i = 0; i < OUTPUT_TYPES.length; ++i) { + var type = OUTPUT_TYPES[i]; + method2[type] = createOutputMethod(type, is2242); + } + return method2; + }; + var nodeWrap = function(method, is224) { + var crypto = eval("require('crypto')"); + var Buffer = eval("require('buffer').Buffer"); + var algorithm = is224 ? "sha224" : "sha256"; + var nodeMethod = function(message) { + if (typeof message === "string") { + return crypto.createHash(algorithm).update(message, "utf8").digest("hex"); + } else { + if (message === null || message === void 0) { + throw new Error(ERROR); + } else if (message.constructor === ArrayBuffer) { + message = new Uint8Array(message); + } + } + if (Array.isArray(message) || ArrayBuffer.isView(message) || message.constructor === Buffer) { + return crypto.createHash(algorithm).update(new Buffer(message)).digest("hex"); + } else { + return method(message); + } + }; + return nodeMethod; + }; + var createHmacOutputMethod = function(outputType, is2242) { + return function(key2, message) { + return new HmacSha256(key2, is2242, true).update(message)[outputType](); + }; + }; + var createHmacMethod = function(is2242) { + var method2 = createHmacOutputMethod("hex", is2242); + method2.create = function(key2) { + return new HmacSha256(key2, is2242); + }; + method2.update = function(key2, message) { + return method2.create(key2).update(message); + }; + for (var i = 0; i < OUTPUT_TYPES.length; ++i) { + var type = OUTPUT_TYPES[i]; + method2[type] = createHmacOutputMethod(type, is2242); + } + return method2; + }; + function Sha256(is2242, sharedMemory) { + if (sharedMemory) { + blocks[0] = blocks[16] = blocks[1] = blocks[2] = blocks[3] = blocks[4] = blocks[5] = blocks[6] = blocks[7] = blocks[8] = blocks[9] = blocks[10] = blocks[11] = blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0; + this.blocks = blocks; + } else { + this.blocks = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; + } + if (is2242) { + this.h0 = 3238371032; + this.h1 = 914150663; + this.h2 = 812702999; + this.h3 = 4144912697; + this.h4 = 4290775857; + this.h5 = 1750603025; + this.h6 = 1694076839; + this.h7 = 3204075428; + } else { + this.h0 = 1779033703; + this.h1 = 3144134277; + this.h2 = 1013904242; + this.h3 = 2773480762; + this.h4 = 1359893119; + this.h5 = 2600822924; + this.h6 = 528734635; + this.h7 = 1541459225; + } + this.block = this.start = this.bytes = this.hBytes = 0; + this.finalized = this.hashed = false; + this.first = true; + this.is224 = is2242; + } + Sha256.prototype.update = function(message) { + if (this.finalized) { + return; + } + var notString, type = typeof message; + if (type !== "string") { + if (type === "object") { + if (message === null) { + throw new Error(ERROR); + } else if (ARRAY_BUFFER && message.constructor === ArrayBuffer) { + message = new Uint8Array(message); + } else if (!Array.isArray(message)) { + if (!ARRAY_BUFFER || !ArrayBuffer.isView(message)) { + throw new Error(ERROR); + } + } + } else { + throw new Error(ERROR); + } + notString = true; + } + var code, index2 = 0, i, length = message.length, blocks2 = this.blocks; + while (index2 < length) { + if (this.hashed) { + this.hashed = false; + blocks2[0] = this.block; + blocks2[16] = blocks2[1] = blocks2[2] = blocks2[3] = blocks2[4] = blocks2[5] = blocks2[6] = blocks2[7] = blocks2[8] = blocks2[9] = blocks2[10] = blocks2[11] = blocks2[12] = blocks2[13] = blocks2[14] = blocks2[15] = 0; + } + if (notString) { + for (i = this.start; index2 < length && i < 64; ++index2) { + blocks2[i >> 2] |= message[index2] << SHIFT[i++ & 3]; + } + } else { + for (i = this.start; index2 < length && i < 64; ++index2) { + code = message.charCodeAt(index2); + if (code < 128) { + blocks2[i >> 2] |= code << SHIFT[i++ & 3]; + } else if (code < 2048) { + blocks2[i >> 2] |= (192 | code >> 6) << SHIFT[i++ & 3]; + blocks2[i >> 2] |= (128 | code & 63) << SHIFT[i++ & 3]; + } else if (code < 55296 || code >= 57344) { + blocks2[i >> 2] |= (224 | code >> 12) << SHIFT[i++ & 3]; + blocks2[i >> 2] |= (128 | code >> 6 & 63) << SHIFT[i++ & 3]; + blocks2[i >> 2] |= (128 | code & 63) << SHIFT[i++ & 3]; + } else { + code = 65536 + ((code & 1023) << 10 | message.charCodeAt(++index2) & 1023); + blocks2[i >> 2] |= (240 | code >> 18) << SHIFT[i++ & 3]; + blocks2[i >> 2] |= (128 | code >> 12 & 63) << SHIFT[i++ & 3]; + blocks2[i >> 2] |= (128 | code >> 6 & 63) << SHIFT[i++ & 3]; + blocks2[i >> 2] |= (128 | code & 63) << SHIFT[i++ & 3]; + } + } + } + this.lastByteIndex = i; + this.bytes += i - this.start; + if (i >= 64) { + this.block = blocks2[16]; + this.start = i - 64; + this.hash(); + this.hashed = true; + } else { + this.start = i; + } + } + if (this.bytes > 4294967295) { + this.hBytes += this.bytes / 4294967296 << 0; + this.bytes = this.bytes % 4294967296; + } + return this; + }; + Sha256.prototype.finalize = function() { + if (this.finalized) { + return; + } + this.finalized = true; + var blocks2 = this.blocks, i = this.lastByteIndex; + blocks2[16] = this.block; + blocks2[i >> 2] |= EXTRA[i & 3]; + this.block = blocks2[16]; + if (i >= 56) { + if (!this.hashed) { + this.hash(); + } + blocks2[0] = this.block; + blocks2[16] = blocks2[1] = blocks2[2] = blocks2[3] = blocks2[4] = blocks2[5] = blocks2[6] = blocks2[7] = blocks2[8] = blocks2[9] = blocks2[10] = blocks2[11] = blocks2[12] = blocks2[13] = blocks2[14] = blocks2[15] = 0; + } + blocks2[14] = this.hBytes << 3 | this.bytes >>> 29; + blocks2[15] = this.bytes << 3; + this.hash(); + }; + Sha256.prototype.hash = function() { + var a = this.h0, b = this.h1, c = this.h2, d = this.h3, e = this.h4, f = this.h5, g = this.h6, h = this.h7, blocks2 = this.blocks, j, s0, s1, maj, t1, t2, ch, ab, da, cd, bc; + for (j = 16; j < 64; ++j) { + t1 = blocks2[j - 15]; + s0 = (t1 >>> 7 | t1 << 25) ^ (t1 >>> 18 | t1 << 14) ^ t1 >>> 3; + t1 = blocks2[j - 2]; + s1 = (t1 >>> 17 | t1 << 15) ^ (t1 >>> 19 | t1 << 13) ^ t1 >>> 10; + blocks2[j] = blocks2[j - 16] + s0 + blocks2[j - 7] + s1 << 0; + } + bc = b & c; + for (j = 0; j < 64; j += 4) { + if (this.first) { + if (this.is224) { + ab = 300032; + t1 = blocks2[0] - 1413257819; + h = t1 - 150054599 << 0; + d = t1 + 24177077 << 0; + } else { + ab = 704751109; + t1 = blocks2[0] - 210244248; + h = t1 - 1521486534 << 0; + d = t1 + 143694565 << 0; + } + this.first = false; + } else { + s0 = (a >>> 2 | a << 30) ^ (a >>> 13 | a << 19) ^ (a >>> 22 | a << 10); + s1 = (e >>> 6 | e << 26) ^ (e >>> 11 | e << 21) ^ (e >>> 25 | e << 7); + ab = a & b; + maj = ab ^ a & c ^ bc; + ch = e & f ^ ~e & g; + t1 = h + s1 + ch + K[j] + blocks2[j]; + t2 = s0 + maj; + h = d + t1 << 0; + d = t1 + t2 << 0; + } + s0 = (d >>> 2 | d << 30) ^ (d >>> 13 | d << 19) ^ (d >>> 22 | d << 10); + s1 = (h >>> 6 | h << 26) ^ (h >>> 11 | h << 21) ^ (h >>> 25 | h << 7); + da = d & a; + maj = da ^ d & b ^ ab; + ch = h & e ^ ~h & f; + t1 = g + s1 + ch + K[j + 1] + blocks2[j + 1]; + t2 = s0 + maj; + g = c + t1 << 0; + c = t1 + t2 << 0; + s0 = (c >>> 2 | c << 30) ^ (c >>> 13 | c << 19) ^ (c >>> 22 | c << 10); + s1 = (g >>> 6 | g << 26) ^ (g >>> 11 | g << 21) ^ (g >>> 25 | g << 7); + cd = c & d; + maj = cd ^ c & a ^ da; + ch = g & h ^ ~g & e; + t1 = f + s1 + ch + K[j + 2] + blocks2[j + 2]; + t2 = s0 + maj; + f = b + t1 << 0; + b = t1 + t2 << 0; + s0 = (b >>> 2 | b << 30) ^ (b >>> 13 | b << 19) ^ (b >>> 22 | b << 10); + s1 = (f >>> 6 | f << 26) ^ (f >>> 11 | f << 21) ^ (f >>> 25 | f << 7); + bc = b & c; + maj = bc ^ b & d ^ cd; + ch = f & g ^ ~f & h; + t1 = e + s1 + ch + K[j + 3] + blocks2[j + 3]; + t2 = s0 + maj; + e = a + t1 << 0; + a = t1 + t2 << 0; + } + this.h0 = this.h0 + a << 0; + this.h1 = this.h1 + b << 0; + this.h2 = this.h2 + c << 0; + this.h3 = this.h3 + d << 0; + this.h4 = this.h4 + e << 0; + this.h5 = this.h5 + f << 0; + this.h6 = this.h6 + g << 0; + this.h7 = this.h7 + h << 0; + }; + Sha256.prototype.hex = function() { + this.finalize(); + var h0 = this.h0, h1 = this.h1, h2 = this.h2, h3 = this.h3, h4 = this.h4, h5 = this.h5, h6 = this.h6, h7 = this.h7; + var hex = HEX_CHARS[h0 >> 28 & 15] + HEX_CHARS[h0 >> 24 & 15] + HEX_CHARS[h0 >> 20 & 15] + HEX_CHARS[h0 >> 16 & 15] + HEX_CHARS[h0 >> 12 & 15] + HEX_CHARS[h0 >> 8 & 15] + HEX_CHARS[h0 >> 4 & 15] + HEX_CHARS[h0 & 15] + HEX_CHARS[h1 >> 28 & 15] + HEX_CHARS[h1 >> 24 & 15] + HEX_CHARS[h1 >> 20 & 15] + HEX_CHARS[h1 >> 16 & 15] + HEX_CHARS[h1 >> 12 & 15] + HEX_CHARS[h1 >> 8 & 15] + HEX_CHARS[h1 >> 4 & 15] + HEX_CHARS[h1 & 15] + HEX_CHARS[h2 >> 28 & 15] + HEX_CHARS[h2 >> 24 & 15] + HEX_CHARS[h2 >> 20 & 15] + HEX_CHARS[h2 >> 16 & 15] + HEX_CHARS[h2 >> 12 & 15] + HEX_CHARS[h2 >> 8 & 15] + HEX_CHARS[h2 >> 4 & 15] + HEX_CHARS[h2 & 15] + HEX_CHARS[h3 >> 28 & 15] + HEX_CHARS[h3 >> 24 & 15] + HEX_CHARS[h3 >> 20 & 15] + HEX_CHARS[h3 >> 16 & 15] + HEX_CHARS[h3 >> 12 & 15] + HEX_CHARS[h3 >> 8 & 15] + HEX_CHARS[h3 >> 4 & 15] + HEX_CHARS[h3 & 15] + HEX_CHARS[h4 >> 28 & 15] + HEX_CHARS[h4 >> 24 & 15] + HEX_CHARS[h4 >> 20 & 15] + HEX_CHARS[h4 >> 16 & 15] + HEX_CHARS[h4 >> 12 & 15] + HEX_CHARS[h4 >> 8 & 15] + HEX_CHARS[h4 >> 4 & 15] + HEX_CHARS[h4 & 15] + HEX_CHARS[h5 >> 28 & 15] + HEX_CHARS[h5 >> 24 & 15] + HEX_CHARS[h5 >> 20 & 15] + HEX_CHARS[h5 >> 16 & 15] + HEX_CHARS[h5 >> 12 & 15] + HEX_CHARS[h5 >> 8 & 15] + HEX_CHARS[h5 >> 4 & 15] + HEX_CHARS[h5 & 15] + HEX_CHARS[h6 >> 28 & 15] + HEX_CHARS[h6 >> 24 & 15] + HEX_CHARS[h6 >> 20 & 15] + HEX_CHARS[h6 >> 16 & 15] + HEX_CHARS[h6 >> 12 & 15] + HEX_CHARS[h6 >> 8 & 15] + HEX_CHARS[h6 >> 4 & 15] + HEX_CHARS[h6 & 15]; + if (!this.is224) { + hex += HEX_CHARS[h7 >> 28 & 15] + HEX_CHARS[h7 >> 24 & 15] + HEX_CHARS[h7 >> 20 & 15] + HEX_CHARS[h7 >> 16 & 15] + HEX_CHARS[h7 >> 12 & 15] + HEX_CHARS[h7 >> 8 & 15] + HEX_CHARS[h7 >> 4 & 15] + HEX_CHARS[h7 & 15]; + } + return hex; + }; + Sha256.prototype.toString = Sha256.prototype.hex; + Sha256.prototype.digest = function() { + this.finalize(); + var h0 = this.h0, h1 = this.h1, h2 = this.h2, h3 = this.h3, h4 = this.h4, h5 = this.h5, h6 = this.h6, h7 = this.h7; + var arr = [ + h0 >> 24 & 255, + h0 >> 16 & 255, + h0 >> 8 & 255, + h0 & 255, + h1 >> 24 & 255, + h1 >> 16 & 255, + h1 >> 8 & 255, + h1 & 255, + h2 >> 24 & 255, + h2 >> 16 & 255, + h2 >> 8 & 255, + h2 & 255, + h3 >> 24 & 255, + h3 >> 16 & 255, + h3 >> 8 & 255, + h3 & 255, + h4 >> 24 & 255, + h4 >> 16 & 255, + h4 >> 8 & 255, + h4 & 255, + h5 >> 24 & 255, + h5 >> 16 & 255, + h5 >> 8 & 255, + h5 & 255, + h6 >> 24 & 255, + h6 >> 16 & 255, + h6 >> 8 & 255, + h6 & 255 + ]; + if (!this.is224) { + arr.push(h7 >> 24 & 255, h7 >> 16 & 255, h7 >> 8 & 255, h7 & 255); + } + return arr; + }; + Sha256.prototype.array = Sha256.prototype.digest; + Sha256.prototype.arrayBuffer = function() { + this.finalize(); + var buffer2 = new ArrayBuffer(this.is224 ? 28 : 32); + var dataView = new DataView(buffer2); + dataView.setUint32(0, this.h0); + dataView.setUint32(4, this.h1); + dataView.setUint32(8, this.h2); + dataView.setUint32(12, this.h3); + dataView.setUint32(16, this.h4); + dataView.setUint32(20, this.h5); + dataView.setUint32(24, this.h6); + if (!this.is224) { + dataView.setUint32(28, this.h7); + } + return buffer2; + }; + function HmacSha256(key2, is2242, sharedMemory) { + var i, type = typeof key2; + if (type === "string") { + var bytes = [], length = key2.length, index2 = 0, code; + for (i = 0; i < length; ++i) { + code = key2.charCodeAt(i); + if (code < 128) { + bytes[index2++] = code; + } else if (code < 2048) { + bytes[index2++] = 192 | code >> 6; + bytes[index2++] = 128 | code & 63; + } else if (code < 55296 || code >= 57344) { + bytes[index2++] = 224 | code >> 12; + bytes[index2++] = 128 | code >> 6 & 63; + bytes[index2++] = 128 | code & 63; + } else { + code = 65536 + ((code & 1023) << 10 | key2.charCodeAt(++i) & 1023); + bytes[index2++] = 240 | code >> 18; + bytes[index2++] = 128 | code >> 12 & 63; + bytes[index2++] = 128 | code >> 6 & 63; + bytes[index2++] = 128 | code & 63; + } + } + key2 = bytes; + } else { + if (type === "object") { + if (key2 === null) { + throw new Error(ERROR); + } else if (ARRAY_BUFFER && key2.constructor === ArrayBuffer) { + key2 = new Uint8Array(key2); + } else if (!Array.isArray(key2)) { + if (!ARRAY_BUFFER || !ArrayBuffer.isView(key2)) { + throw new Error(ERROR); + } + } + } else { + throw new Error(ERROR); + } + } + if (key2.length > 64) { + key2 = new Sha256(is2242, true).update(key2).array(); + } + var oKeyPad = [], iKeyPad = []; + for (i = 0; i < 64; ++i) { + var b = key2[i] || 0; + oKeyPad[i] = 92 ^ b; + iKeyPad[i] = 54 ^ b; + } + Sha256.call(this, is2242, sharedMemory); + this.update(iKeyPad); + this.oKeyPad = oKeyPad; + this.inner = true; + this.sharedMemory = sharedMemory; + } + HmacSha256.prototype = new Sha256(); + HmacSha256.prototype.finalize = function() { + Sha256.prototype.finalize.call(this); + if (this.inner) { + this.inner = false; + var innerHash = this.array(); + Sha256.call(this, this.is224, this.sharedMemory); + this.update(this.oKeyPad); + this.update(innerHash); + Sha256.prototype.finalize.call(this); + } + }; + var exports = createMethod(); + exports.sha256 = exports; + exports.sha224 = createMethod(true); + exports.sha256.hmac = createHmacMethod(); + exports.sha224.hmac = createHmacMethod(true); + if (COMMON_JS) { + module.exports = exports; + } else { + root.sha256 = exports.sha256; + root.sha224 = exports.sha224; + if (AMD) { + define(function() { + return exports; + }); + } + } + })(); + } +}); + +// node_modules/.pnpm/hogan.js@3.0.2/node_modules/hogan.js/lib/compiler.js +var require_compiler = __commonJS({ + "node_modules/.pnpm/hogan.js@3.0.2/node_modules/hogan.js/lib/compiler.js"(exports2) { + init_polyfill_buffer(); + (function(Hogan4) { + var rIsWhitespace = /\S/, rQuot = /\"/g, rNewline = /\n/g, rCr = /\r/g, rSlash = /\\/g, rLineSep = /\u2028/, rParagraphSep = /\u2029/; + Hogan4.tags = { + "#": 1, + "^": 2, + "<": 3, + "$": 4, + "/": 5, + "!": 6, + ">": 7, + "=": 8, + "_v": 9, + "{": 10, + "&": 11, + "_t": 12 + }; + Hogan4.scan = function scan(text2, delimiters) { + var len = text2.length, IN_TEXT = 0, IN_TAG_TYPE = 1, IN_TAG = 2, state = IN_TEXT, tagType = null, tag2 = null, buf = "", tokens = [], seenTag = false, i = 0, lineStart = 0, otag = "{{", ctag = "}}"; + function addBuf() { + if (buf.length > 0) { + tokens.push({ tag: "_t", text: new String(buf) }); + buf = ""; + } + } + function lineIsWhitespace() { + var isAllWhitespace = true; + for (var j = lineStart; j < tokens.length; j++) { + isAllWhitespace = Hogan4.tags[tokens[j].tag] < Hogan4.tags["_v"] || tokens[j].tag == "_t" && tokens[j].text.match(rIsWhitespace) === null; + if (!isAllWhitespace) { + return false; + } + } + return isAllWhitespace; + } + function filterLine(haveSeenTag, noNewLine) { + addBuf(); + if (haveSeenTag && lineIsWhitespace()) { + for (var j = lineStart, next; j < tokens.length; j++) { + if (tokens[j].text) { + if ((next = tokens[j + 1]) && next.tag == ">") { + next.indent = tokens[j].text.toString(); + } + tokens.splice(j, 1); + } + } + } else if (!noNewLine) { + tokens.push({ tag: "\n" }); + } + seenTag = false; + lineStart = tokens.length; + } + function changeDelimiters(text3, index2) { + var close = "=" + ctag, closeIndex = text3.indexOf(close, index2), delimiters2 = trim( + text3.substring(text3.indexOf("=", index2) + 1, closeIndex) + ).split(" "); + otag = delimiters2[0]; + ctag = delimiters2[delimiters2.length - 1]; + return closeIndex + close.length - 1; + } + if (delimiters) { + delimiters = delimiters.split(" "); + otag = delimiters[0]; + ctag = delimiters[1]; + } + for (i = 0; i < len; i++) { + if (state == IN_TEXT) { + if (tagChange(otag, text2, i)) { + --i; + addBuf(); + state = IN_TAG_TYPE; + } else { + if (text2.charAt(i) == "\n") { + filterLine(seenTag); + } else { + buf += text2.charAt(i); + } + } + } else if (state == IN_TAG_TYPE) { + i += otag.length - 1; + tag2 = Hogan4.tags[text2.charAt(i + 1)]; + tagType = tag2 ? text2.charAt(i + 1) : "_v"; + if (tagType == "=") { + i = changeDelimiters(text2, i); + state = IN_TEXT; + } else { + if (tag2) { + i++; + } + state = IN_TAG; + } + seenTag = i; + } else { + if (tagChange(ctag, text2, i)) { + tokens.push({ + tag: tagType, + n: trim(buf), + otag, + ctag, + i: tagType == "/" ? seenTag - otag.length : i + ctag.length + }); + buf = ""; + i += ctag.length - 1; + state = IN_TEXT; + if (tagType == "{") { + if (ctag == "}}") { + i++; + } else { + cleanTripleStache(tokens[tokens.length - 1]); + } + } + } else { + buf += text2.charAt(i); + } + } + } + filterLine(seenTag, true); + return tokens; + }; + function cleanTripleStache(token) { + if (token.n.substr(token.n.length - 1) === "}") { + token.n = token.n.substring(0, token.n.length - 1); + } + } + function trim(s) { + if (s.trim) { + return s.trim(); + } + return s.replace(/^\s*|\s*$/g, ""); + } + function tagChange(tag2, text2, index2) { + if (text2.charAt(index2) != tag2.charAt(0)) { + return false; + } + for (var i = 1, l = tag2.length; i < l; i++) { + if (text2.charAt(index2 + i) != tag2.charAt(i)) { + return false; + } + } + return true; + } + var allowedInSuper = { "_t": true, "\n": true, "$": true, "/": true }; + function buildTree(tokens, kind, stack, customTags) { + var instructions = [], opener = null, tail = null, token = null; + tail = stack[stack.length - 1]; + while (tokens.length > 0) { + token = tokens.shift(); + if (tail && tail.tag == "<" && !(token.tag in allowedInSuper)) { + throw new Error("Illegal content in < super tag."); + } + if (Hogan4.tags[token.tag] <= Hogan4.tags["$"] || isOpener(token, customTags)) { + stack.push(token); + token.nodes = buildTree(tokens, token.tag, stack, customTags); + } else if (token.tag == "/") { + if (stack.length === 0) { + throw new Error("Closing tag without opener: /" + token.n); + } + opener = stack.pop(); + if (token.n != opener.n && !isCloser(token.n, opener.n, customTags)) { + throw new Error("Nesting error: " + opener.n + " vs. " + token.n); + } + opener.end = token.i; + return instructions; + } else if (token.tag == "\n") { + token.last = tokens.length == 0 || tokens[0].tag == "\n"; + } + instructions.push(token); + } + if (stack.length > 0) { + throw new Error("missing closing tag: " + stack.pop().n); + } + return instructions; + } + function isOpener(token, tags) { + for (var i = 0, l = tags.length; i < l; i++) { + if (tags[i].o == token.n) { + token.tag = "#"; + return true; + } + } + } + function isCloser(close, open, tags) { + for (var i = 0, l = tags.length; i < l; i++) { + if (tags[i].c == close && tags[i].o == open) { + return true; + } + } + } + function stringifySubstitutions(obj) { + var items = []; + for (var key2 in obj) { + items.push('"' + esc(key2) + '": function(c,p,t,i) {' + obj[key2] + "}"); + } + return "{ " + items.join(",") + " }"; + } + function stringifyPartials(codeObj) { + var partials = []; + for (var key2 in codeObj.partials) { + partials.push('"' + esc(key2) + '":{name:"' + esc(codeObj.partials[key2].name) + '", ' + stringifyPartials(codeObj.partials[key2]) + "}"); + } + return "partials: {" + partials.join(",") + "}, subs: " + stringifySubstitutions(codeObj.subs); + } + Hogan4.stringify = function(codeObj, text2, options) { + return "{code: function (c,p,i) { " + Hogan4.wrapMain(codeObj.code) + " }," + stringifyPartials(codeObj) + "}"; + }; + var serialNo = 0; + Hogan4.generate = function(tree, text2, options) { + serialNo = 0; + var context = { code: "", subs: {}, partials: {} }; + Hogan4.walk(tree, context); + if (options.asString) { + return this.stringify(context, text2, options); + } + return this.makeTemplate(context, text2, options); + }; + Hogan4.wrapMain = function(code) { + return 'var t=this;t.b(i=i||"");' + code + "return t.fl();"; + }; + Hogan4.template = Hogan4.Template; + Hogan4.makeTemplate = function(codeObj, text2, options) { + var template = this.makePartials(codeObj); + template.code = new Function("c", "p", "i", this.wrapMain(codeObj.code)); + return new this.template(template, text2, this, options); + }; + Hogan4.makePartials = function(codeObj) { + var key2, template = { subs: {}, partials: codeObj.partials, name: codeObj.name }; + for (key2 in template.partials) { + template.partials[key2] = this.makePartials(template.partials[key2]); + } + for (key2 in codeObj.subs) { + template.subs[key2] = new Function("c", "p", "t", "i", codeObj.subs[key2]); + } + return template; + }; + function esc(s) { + return s.replace(rSlash, "\\\\").replace(rQuot, '\\"').replace(rNewline, "\\n").replace(rCr, "\\r").replace(rLineSep, "\\u2028").replace(rParagraphSep, "\\u2029"); + } + function chooseMethod(s) { + return ~s.indexOf(".") ? "d" : "f"; + } + function createPartial(node, context) { + var prefix = "<" + (context.prefix || ""); + var sym = prefix + node.n + serialNo++; + context.partials[sym] = { name: node.n, partials: {} }; + context.code += 't.b(t.rp("' + esc(sym) + '",c,p,"' + (node.indent || "") + '"));'; + return sym; + } + Hogan4.codegen = { + "#": function(node, context) { + context.code += "if(t.s(t." + chooseMethod(node.n) + '("' + esc(node.n) + '",c,p,1),c,p,0,' + node.i + "," + node.end + ',"' + node.otag + " " + node.ctag + '")){t.rs(c,p,function(c,p,t){'; + Hogan4.walk(node.nodes, context); + context.code += "});c.pop();}"; + }, + "^": function(node, context) { + context.code += "if(!t.s(t." + chooseMethod(node.n) + '("' + esc(node.n) + '",c,p,1),c,p,1,0,0,"")){'; + Hogan4.walk(node.nodes, context); + context.code += "};"; + }, + ">": createPartial, + "<": function(node, context) { + var ctx = { partials: {}, code: "", subs: {}, inPartial: true }; + Hogan4.walk(node.nodes, ctx); + var template = context.partials[createPartial(node, context)]; + template.subs = ctx.subs; + template.partials = ctx.partials; + }, + "$": function(node, context) { + var ctx = { subs: {}, code: "", partials: context.partials, prefix: node.n }; + Hogan4.walk(node.nodes, ctx); + context.subs[node.n] = ctx.code; + if (!context.inPartial) { + context.code += 't.sub("' + esc(node.n) + '",c,p,i);'; + } + }, + "\n": function(node, context) { + context.code += write('"\\n"' + (node.last ? "" : " + i")); + }, + "_v": function(node, context) { + context.code += "t.b(t.v(t." + chooseMethod(node.n) + '("' + esc(node.n) + '",c,p,0)));'; + }, + "_t": function(node, context) { + context.code += write('"' + esc(node.text) + '"'); + }, + "{": tripleStache, + "&": tripleStache + }; + function tripleStache(node, context) { + context.code += "t.b(t.t(t." + chooseMethod(node.n) + '("' + esc(node.n) + '",c,p,0)));'; + } + function write(s) { + return "t.b(" + s + ");"; + } + Hogan4.walk = function(nodelist, context) { + var func; + for (var i = 0, l = nodelist.length; i < l; i++) { + func = Hogan4.codegen[nodelist[i].tag]; + func && func(nodelist[i], context); + } + return context; + }; + Hogan4.parse = function(tokens, text2, options) { + options = options || {}; + return buildTree(tokens, "", [], options.sectionTags || []); + }; + Hogan4.cache = {}; + Hogan4.cacheKey = function(text2, options) { + return [text2, !!options.asString, !!options.disableLambda, options.delimiters, !!options.modelGet].join("||"); + }; + Hogan4.compile = function(text2, options) { + options = options || {}; + var key2 = Hogan4.cacheKey(text2, options); + var template = this.cache[key2]; + if (template) { + var partials = template.partials; + for (var name in partials) { + delete partials[name].instance; + } + return template; + } + template = this.generate(this.parse(this.scan(text2, options.delimiters), text2, options), text2, options); + return this.cache[key2] = template; + }; + })(typeof exports2 !== "undefined" ? exports2 : Hogan); + } +}); + +// node_modules/.pnpm/hogan.js@3.0.2/node_modules/hogan.js/lib/template.js +var require_template = __commonJS({ + "node_modules/.pnpm/hogan.js@3.0.2/node_modules/hogan.js/lib/template.js"(exports2) { + init_polyfill_buffer(); + var Hogan4 = {}; + (function(Hogan5) { + Hogan5.Template = function(codeObj, text2, compiler, options) { + codeObj = codeObj || {}; + this.r = codeObj.code || this.r; + this.c = compiler; + this.options = options || {}; + this.text = text2 || ""; + this.partials = codeObj.partials || {}; + this.subs = codeObj.subs || {}; + this.buf = ""; + }; + Hogan5.Template.prototype = { + // render: replaced by generated code. + r: function(context, partials, indent2) { + return ""; + }, + // variable escaping + v: hoganEscape, + // triple stache + t: coerceToString, + render: function render2(context, partials, indent2) { + return this.ri([context], partials || {}, indent2); + }, + // render internal -- a hook for overrides that catches partials too + ri: function(context, partials, indent2) { + return this.r(context, partials, indent2); + }, + // ensurePartial + ep: function(symbol, partials) { + var partial = this.partials[symbol]; + var template = partials[partial.name]; + if (partial.instance && partial.base == template) { + return partial.instance; + } + if (typeof template == "string") { + if (!this.c) { + throw new Error("No compiler available."); + } + template = this.c.compile(template, this.options); + } + if (!template) { + return null; + } + this.partials[symbol].base = template; + if (partial.subs) { + if (!partials.stackText) + partials.stackText = {}; + for (key in partial.subs) { + if (!partials.stackText[key]) { + partials.stackText[key] = this.activeSub !== void 0 && partials.stackText[this.activeSub] ? partials.stackText[this.activeSub] : this.text; + } + } + template = createSpecializedPartial( + template, + partial.subs, + partial.partials, + this.stackSubs, + this.stackPartials, + partials.stackText + ); + } + this.partials[symbol].instance = template; + return template; + }, + // tries to find a partial in the current scope and render it + rp: function(symbol, context, partials, indent2) { + var partial = this.ep(symbol, partials); + if (!partial) { + return ""; + } + return partial.ri(context, partials, indent2); + }, + // render a section + rs: function(context, partials, section) { + var tail = context[context.length - 1]; + if (!isArray(tail)) { + section(context, partials, this); + return; + } + for (var i = 0; i < tail.length; i++) { + context.push(tail[i]); + section(context, partials, this); + context.pop(); + } + }, + // maybe start a section + s: function(val, ctx, partials, inverted, start, end, tags) { + var pass; + if (isArray(val) && val.length === 0) { + return false; + } + if (typeof val == "function") { + val = this.ms(val, ctx, partials, inverted, start, end, tags); + } + pass = !!val; + if (!inverted && pass && ctx) { + ctx.push(typeof val == "object" ? val : ctx[ctx.length - 1]); + } + return pass; + }, + // find values with dotted names + d: function(key2, ctx, partials, returnFound) { + var found, names = key2.split("."), val = this.f(names[0], ctx, partials, returnFound), doModelGet = this.options.modelGet, cx = null; + if (key2 === "." && isArray(ctx[ctx.length - 2])) { + val = ctx[ctx.length - 1]; + } else { + for (var i = 1; i < names.length; i++) { + found = findInScope(names[i], val, doModelGet); + if (found !== void 0) { + cx = val; + val = found; + } else { + val = ""; + } + } + } + if (returnFound && !val) { + return false; + } + if (!returnFound && typeof val == "function") { + ctx.push(cx); + val = this.mv(val, ctx, partials); + ctx.pop(); + } + return val; + }, + // find values with normal names + f: function(key2, ctx, partials, returnFound) { + var val = false, v = null, found = false, doModelGet = this.options.modelGet; + for (var i = ctx.length - 1; i >= 0; i--) { + v = ctx[i]; + val = findInScope(key2, v, doModelGet); + if (val !== void 0) { + found = true; + break; + } + } + if (!found) { + return returnFound ? false : ""; + } + if (!returnFound && typeof val == "function") { + val = this.mv(val, ctx, partials); + } + return val; + }, + // higher order templates + ls: function(func, cx, partials, text2, tags) { + var oldTags = this.options.delimiters; + this.options.delimiters = tags; + this.b(this.ct(coerceToString(func.call(cx, text2)), cx, partials)); + this.options.delimiters = oldTags; + return false; + }, + // compile text + ct: function(text2, cx, partials) { + if (this.options.disableLambda) { + throw new Error("Lambda features disabled."); + } + return this.c.compile(text2, this.options).render(cx, partials); + }, + // template result buffering + b: function(s) { + this.buf += s; + }, + fl: function() { + var r = this.buf; + this.buf = ""; + return r; + }, + // method replace section + ms: function(func, ctx, partials, inverted, start, end, tags) { + var textSource, cx = ctx[ctx.length - 1], result = func.call(cx); + if (typeof result == "function") { + if (inverted) { + return true; + } else { + textSource = this.activeSub && this.subsText && this.subsText[this.activeSub] ? this.subsText[this.activeSub] : this.text; + return this.ls(result, cx, partials, textSource.substring(start, end), tags); + } + } + return result; + }, + // method replace variable + mv: function(func, ctx, partials) { + var cx = ctx[ctx.length - 1]; + var result = func.call(cx); + if (typeof result == "function") { + return this.ct(coerceToString(result.call(cx)), cx, partials); + } + return result; + }, + sub: function(name, context, partials, indent2) { + var f = this.subs[name]; + if (f) { + this.activeSub = name; + f(context, partials, this, indent2); + this.activeSub = false; + } + } + }; + function findInScope(key2, scope, doModelGet) { + var val; + if (scope && typeof scope == "object") { + if (scope[key2] !== void 0) { + val = scope[key2]; + } else if (doModelGet && scope.get && typeof scope.get == "function") { + val = scope.get(key2); + } + } + return val; + } + function createSpecializedPartial(instance10, subs, partials, stackSubs, stackPartials, stackText) { + function PartialTemplate() { + } + ; + PartialTemplate.prototype = instance10; + function Substitutions() { + } + ; + Substitutions.prototype = instance10.subs; + var key2; + var partial = new PartialTemplate(); + partial.subs = new Substitutions(); + partial.subsText = {}; + partial.buf = ""; + stackSubs = stackSubs || {}; + partial.stackSubs = stackSubs; + partial.subsText = stackText; + for (key2 in subs) { + if (!stackSubs[key2]) + stackSubs[key2] = subs[key2]; + } + for (key2 in stackSubs) { + partial.subs[key2] = stackSubs[key2]; + } + stackPartials = stackPartials || {}; + partial.stackPartials = stackPartials; + for (key2 in partials) { + if (!stackPartials[key2]) + stackPartials[key2] = partials[key2]; + } + for (key2 in stackPartials) { + partial.partials[key2] = stackPartials[key2]; + } + return partial; + } + var rAmp = /&/g, rLt = //g, rApos = /\'/g, rQuot = /\"/g, hChars = /[&<>\"\']/; + function coerceToString(val) { + return String(val === null || val === void 0 ? "" : val); + } + function hoganEscape(str) { + str = coerceToString(str); + return hChars.test(str) ? str.replace(rAmp, "&").replace(rLt, "<").replace(rGt, ">").replace(rApos, "'").replace(rQuot, """) : str; + } + var isArray = Array.isArray || function(a) { + return Object.prototype.toString.call(a) === "[object Array]"; + }; + })(typeof exports2 !== "undefined" ? exports2 : Hogan4); + } +}); + +// node_modules/.pnpm/hogan.js@3.0.2/node_modules/hogan.js/lib/hogan.js +var require_hogan = __commonJS({ + "node_modules/.pnpm/hogan.js@3.0.2/node_modules/hogan.js/lib/hogan.js"(exports2, module2) { + init_polyfill_buffer(); + var Hogan4 = require_compiler(); + Hogan4.Template = require_template().Template; + Hogan4.template = Hogan4.Template; + module2.exports = Hogan4; + } +}); + +// node_modules/.pnpm/feather-icons@4.29.0/node_modules/feather-icons/dist/feather.js +var require_feather = __commonJS({ + "node_modules/.pnpm/feather-icons@4.29.0/node_modules/feather-icons/dist/feather.js"(exports2, module2) { + init_polyfill_buffer(); + (function webpackUniversalModuleDefinition(root2, factory) { + if (typeof exports2 === "object" && typeof module2 === "object") + module2.exports = factory(); + else if (typeof define === "function" && define.amd) + define([], factory); + else if (typeof exports2 === "object") + exports2["feather"] = factory(); + else + root2["feather"] = factory(); + })(typeof self !== "undefined" ? self : exports2, function() { + return ( + /******/ + function(modules) { + var installedModules = {}; + function __webpack_require__(moduleId) { + if (installedModules[moduleId]) { + return installedModules[moduleId].exports; + } + var module3 = installedModules[moduleId] = { + /******/ + i: moduleId, + /******/ + l: false, + /******/ + exports: {} + /******/ + }; + modules[moduleId].call(module3.exports, module3, module3.exports, __webpack_require__); + module3.l = true; + return module3.exports; + } + __webpack_require__.m = modules; + __webpack_require__.c = installedModules; + __webpack_require__.d = function(exports3, name, getter) { + if (!__webpack_require__.o(exports3, name)) { + Object.defineProperty(exports3, name, { + /******/ + configurable: false, + /******/ + enumerable: true, + /******/ + get: getter + /******/ + }); + } + }; + __webpack_require__.r = function(exports3) { + Object.defineProperty(exports3, "__esModule", { value: true }); + }; + __webpack_require__.n = function(module3) { + var getter = module3 && module3.__esModule ? ( + /******/ + function getDefault() { + return module3["default"]; + } + ) : ( + /******/ + function getModuleExports() { + return module3; + } + ); + __webpack_require__.d(getter, "a", getter); + return getter; + }; + __webpack_require__.o = function(object, property) { + return Object.prototype.hasOwnProperty.call(object, property); + }; + __webpack_require__.p = ""; + return __webpack_require__(__webpack_require__.s = 0); + }({ + /***/ + "./dist/icons.json": ( + /*!*************************!*\ + !*** ./dist/icons.json ***! + \*************************/ + /*! exports provided: activity, airplay, alert-circle, alert-octagon, alert-triangle, align-center, align-justify, align-left, align-right, anchor, aperture, archive, arrow-down-circle, arrow-down-left, arrow-down-right, arrow-down, arrow-left-circle, arrow-left, arrow-right-circle, arrow-right, arrow-up-circle, arrow-up-left, arrow-up-right, arrow-up, at-sign, award, bar-chart-2, bar-chart, battery-charging, battery, bell-off, bell, bluetooth, bold, book-open, book, bookmark, box, briefcase, calendar, camera-off, camera, cast, check-circle, check-square, check, chevron-down, chevron-left, chevron-right, chevron-up, chevrons-down, chevrons-left, chevrons-right, chevrons-up, chrome, circle, clipboard, clock, cloud-drizzle, cloud-lightning, cloud-off, cloud-rain, cloud-snow, cloud, code, codepen, codesandbox, coffee, columns, command, compass, copy, corner-down-left, corner-down-right, corner-left-down, corner-left-up, corner-right-down, corner-right-up, corner-up-left, corner-up-right, cpu, credit-card, crop, crosshair, database, delete, disc, divide-circle, divide-square, divide, dollar-sign, download-cloud, download, dribbble, droplet, edit-2, edit-3, edit, external-link, eye-off, eye, facebook, fast-forward, feather, figma, file-minus, file-plus, file-text, file, film, filter, flag, folder-minus, folder-plus, folder, framer, frown, gift, git-branch, git-commit, git-merge, git-pull-request, github, gitlab, globe, grid, hard-drive, hash, headphones, heart, help-circle, hexagon, home, image, inbox, info, instagram, italic, key, layers, layout, life-buoy, link-2, link, linkedin, list, loader, lock, log-in, log-out, mail, map-pin, map, maximize-2, maximize, meh, menu, message-circle, message-square, mic-off, mic, minimize-2, minimize, minus-circle, minus-square, minus, monitor, moon, more-horizontal, more-vertical, mouse-pointer, move, music, navigation-2, navigation, octagon, package, paperclip, pause-circle, pause, pen-tool, percent, phone-call, phone-forwarded, phone-incoming, phone-missed, phone-off, phone-outgoing, phone, pie-chart, play-circle, play, plus-circle, plus-square, plus, pocket, power, printer, radio, refresh-ccw, refresh-cw, repeat, rewind, rotate-ccw, rotate-cw, rss, save, scissors, search, send, server, settings, share-2, share, shield-off, shield, shopping-bag, shopping-cart, shuffle, sidebar, skip-back, skip-forward, slack, slash, sliders, smartphone, smile, speaker, square, star, stop-circle, sun, sunrise, sunset, table, tablet, tag, target, terminal, thermometer, thumbs-down, thumbs-up, toggle-left, toggle-right, tool, trash-2, trash, trello, trending-down, trending-up, triangle, truck, tv, twitch, twitter, type, umbrella, underline, unlock, upload-cloud, upload, user-check, user-minus, user-plus, user-x, user, users, video-off, video, voicemail, volume-1, volume-2, volume-x, volume, watch, wifi-off, wifi, wind, x-circle, x-octagon, x-square, x, youtube, zap-off, zap, zoom-in, zoom-out, default */ + /***/ + function(module3) { + module3.exports = { "activity": '', "airplay": '', "alert-circle": '', "alert-octagon": '', "alert-triangle": '', "align-center": '', "align-justify": '', "align-left": '', "align-right": '', "anchor": '', "aperture": '', "archive": '', "arrow-down-circle": '', "arrow-down-left": '', "arrow-down-right": '', "arrow-down": '', "arrow-left-circle": '', "arrow-left": '', "arrow-right-circle": '', "arrow-right": '', "arrow-up-circle": '', "arrow-up-left": '', "arrow-up-right": '', "arrow-up": '', "at-sign": '', "award": '', "bar-chart-2": '', "bar-chart": '', "battery-charging": '', "battery": '', "bell-off": '', "bell": '', "bluetooth": '', "bold": '', "book-open": '', "book": '', "bookmark": '', "box": '', "briefcase": '', "calendar": '', "camera-off": '', "camera": '', "cast": '', "check-circle": '', "check-square": '', "check": '', "chevron-down": '', "chevron-left": '', "chevron-right": '', "chevron-up": '', "chevrons-down": '', "chevrons-left": '', "chevrons-right": '', "chevrons-up": '', "chrome": '', "circle": '', "clipboard": '', "clock": '', "cloud-drizzle": '', "cloud-lightning": '', "cloud-off": '', "cloud-rain": '', "cloud-snow": '', "cloud": '', "code": '', "codepen": '', "codesandbox": '', "coffee": '', "columns": '', "command": '', "compass": '', "copy": '', "corner-down-left": '', "corner-down-right": '', "corner-left-down": '', "corner-left-up": '', "corner-right-down": '', "corner-right-up": '', "corner-up-left": '', "corner-up-right": '', "cpu": '', "credit-card": '', "crop": '', "crosshair": '', "database": '', "delete": '', "disc": '', "divide-circle": '', "divide-square": '', "divide": '', "dollar-sign": '', "download-cloud": '', "download": '', "dribbble": '', "droplet": '', "edit-2": '', "edit-3": '', "edit": '', "external-link": '', "eye-off": '', "eye": '', "facebook": '', "fast-forward": '', "feather": '', "figma": '', "file-minus": '', "file-plus": '', "file-text": '', "file": '', "film": '', "filter": '', "flag": '', "folder-minus": '', "folder-plus": '', "folder": '', "framer": '', "frown": '', "gift": '', "git-branch": '', "git-commit": '', "git-merge": '', "git-pull-request": '', "github": '', "gitlab": '', "globe": '', "grid": '', "hard-drive": '', "hash": '', "headphones": '', "heart": '', "help-circle": '', "hexagon": '', "home": '', "image": '', "inbox": '', "info": '', "instagram": '', "italic": '', "key": '', "layers": '', "layout": '', "life-buoy": '', "link-2": '', "link": '', "linkedin": '', "list": '', "loader": '', "lock": '', "log-in": '', "log-out": '', "mail": '', "map-pin": '', "map": '', "maximize-2": '', "maximize": '', "meh": '', "menu": '', "message-circle": '', "message-square": '', "mic-off": '', "mic": '', "minimize-2": '', "minimize": '', "minus-circle": '', "minus-square": '', "minus": '', "monitor": '', "moon": '', "more-horizontal": '', "more-vertical": '', "mouse-pointer": '', "move": '', "music": '', "navigation-2": '', "navigation": '', "octagon": '', "package": '', "paperclip": '', "pause-circle": '', "pause": '', "pen-tool": '', "percent": '', "phone-call": '', "phone-forwarded": '', "phone-incoming": '', "phone-missed": '', "phone-off": '', "phone-outgoing": '', "phone": '', "pie-chart": '', "play-circle": '', "play": '', "plus-circle": '', "plus-square": '', "plus": '', "pocket": '', "power": '', "printer": '', "radio": '', "refresh-ccw": '', "refresh-cw": '', "repeat": '', "rewind": '', "rotate-ccw": '', "rotate-cw": '', "rss": '', "save": '', "scissors": '', "search": '', "send": '', "server": '', "settings": '', "share-2": '', "share": '', "shield-off": '', "shield": '', "shopping-bag": '', "shopping-cart": '', "shuffle": '', "sidebar": '', "skip-back": '', "skip-forward": '', "slack": '', "slash": '', "sliders": '', "smartphone": '', "smile": '', "speaker": '', "square": '', "star": '', "stop-circle": '', "sun": '', "sunrise": '', "sunset": '', "table": '', "tablet": '', "tag": '', "target": '', "terminal": '', "thermometer": '', "thumbs-down": '', "thumbs-up": '', "toggle-left": '', "toggle-right": '', "tool": '', "trash-2": '', "trash": '', "trello": '', "trending-down": '', "trending-up": '', "triangle": '', "truck": '', "tv": '', "twitch": '', "twitter": '', "type": '', "umbrella": '', "underline": '', "unlock": '', "upload-cloud": '', "upload": '', "user-check": '', "user-minus": '', "user-plus": '', "user-x": '', "user": '', "users": '', "video-off": '', "video": '', "voicemail": '', "volume-1": '', "volume-2": '', "volume-x": '', "volume": '', "watch": '', "wifi-off": '', "wifi": '', "wind": '', "x-circle": '', "x-octagon": '', "x-square": '', "x": '', "youtube": '', "zap-off": '', "zap": '', "zoom-in": '', "zoom-out": '' }; + } + ), + /***/ + "./node_modules/classnames/dedupe.js": ( + /*!*******************************************!*\ + !*** ./node_modules/classnames/dedupe.js ***! + \*******************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__; + (function() { + "use strict"; + var classNames = function() { + function StorageObject() { + } + StorageObject.prototype = /* @__PURE__ */ Object.create(null); + function _parseArray(resultSet, array) { + var length = array.length; + for (var i = 0; i < length; ++i) { + _parse(resultSet, array[i]); + } + } + var hasOwn = {}.hasOwnProperty; + function _parseNumber(resultSet, num2) { + resultSet[num2] = true; + } + function _parseObject(resultSet, object) { + for (var k in object) { + if (hasOwn.call(object, k)) { + resultSet[k] = !!object[k]; + } + } + } + var SPACE = /\s+/; + function _parseString(resultSet, str) { + var array = str.split(SPACE); + var length = array.length; + for (var i = 0; i < length; ++i) { + resultSet[array[i]] = true; + } + } + function _parse(resultSet, arg) { + if (!arg) + return; + var argType = typeof arg; + if (argType === "string") { + _parseString(resultSet, arg); + } else if (Array.isArray(arg)) { + _parseArray(resultSet, arg); + } else if (argType === "object") { + _parseObject(resultSet, arg); + } else if (argType === "number") { + _parseNumber(resultSet, arg); + } + } + function _classNames() { + var len = arguments.length; + var args = Array(len); + for (var i = 0; i < len; i++) { + args[i] = arguments[i]; + } + var classSet = new StorageObject(); + _parseArray(classSet, args); + var list = []; + for (var k in classSet) { + if (classSet[k]) { + list.push(k); + } + } + return list.join(" "); + } + return _classNames; + }(); + if (typeof module3 !== "undefined" && module3.exports) { + module3.exports = classNames; + } else if (true) { + !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function() { + return classNames; + }.apply(exports3, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== void 0 && (module3.exports = __WEBPACK_AMD_DEFINE_RESULT__)); + } else { + } + })(); + } + ), + /***/ + "./node_modules/core-js/es/array/from.js": ( + /*!***********************************************!*\ + !*** ./node_modules/core-js/es/array/from.js ***! + \***********************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + __webpack_require__( + /*! ../../modules/es.string.iterator */ + "./node_modules/core-js/modules/es.string.iterator.js" + ); + __webpack_require__( + /*! ../../modules/es.array.from */ + "./node_modules/core-js/modules/es.array.from.js" + ); + var path2 = __webpack_require__( + /*! ../../internals/path */ + "./node_modules/core-js/internals/path.js" + ); + module3.exports = path2.Array.from; + } + ), + /***/ + "./node_modules/core-js/internals/a-function.js": ( + /*!******************************************************!*\ + !*** ./node_modules/core-js/internals/a-function.js ***! + \******************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3) { + module3.exports = function(it) { + if (typeof it != "function") { + throw TypeError(String(it) + " is not a function"); + } + return it; + }; + } + ), + /***/ + "./node_modules/core-js/internals/an-object.js": ( + /*!*****************************************************!*\ + !*** ./node_modules/core-js/internals/an-object.js ***! + \*****************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var isObject = __webpack_require__( + /*! ../internals/is-object */ + "./node_modules/core-js/internals/is-object.js" + ); + module3.exports = function(it) { + if (!isObject(it)) { + throw TypeError(String(it) + " is not an object"); + } + return it; + }; + } + ), + /***/ + "./node_modules/core-js/internals/array-from.js": ( + /*!******************************************************!*\ + !*** ./node_modules/core-js/internals/array-from.js ***! + \******************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + "use strict"; + var bind = __webpack_require__( + /*! ../internals/bind-context */ + "./node_modules/core-js/internals/bind-context.js" + ); + var toObject = __webpack_require__( + /*! ../internals/to-object */ + "./node_modules/core-js/internals/to-object.js" + ); + var callWithSafeIterationClosing = __webpack_require__( + /*! ../internals/call-with-safe-iteration-closing */ + "./node_modules/core-js/internals/call-with-safe-iteration-closing.js" + ); + var isArrayIteratorMethod = __webpack_require__( + /*! ../internals/is-array-iterator-method */ + "./node_modules/core-js/internals/is-array-iterator-method.js" + ); + var toLength = __webpack_require__( + /*! ../internals/to-length */ + "./node_modules/core-js/internals/to-length.js" + ); + var createProperty = __webpack_require__( + /*! ../internals/create-property */ + "./node_modules/core-js/internals/create-property.js" + ); + var getIteratorMethod = __webpack_require__( + /*! ../internals/get-iterator-method */ + "./node_modules/core-js/internals/get-iterator-method.js" + ); + module3.exports = function from(arrayLike) { + var O = toObject(arrayLike); + var C = typeof this == "function" ? this : Array; + var argumentsLength = arguments.length; + var mapfn = argumentsLength > 1 ? arguments[1] : void 0; + var mapping = mapfn !== void 0; + var index2 = 0; + var iteratorMethod = getIteratorMethod(O); + var length, result, step, iterator; + if (mapping) + mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : void 0, 2); + if (iteratorMethod != void 0 && !(C == Array && isArrayIteratorMethod(iteratorMethod))) { + iterator = iteratorMethod.call(O); + result = new C(); + for (; !(step = iterator.next()).done; index2++) { + createProperty( + result, + index2, + mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index2], true) : step.value + ); + } + } else { + length = toLength(O.length); + result = new C(length); + for (; length > index2; index2++) { + createProperty(result, index2, mapping ? mapfn(O[index2], index2) : O[index2]); + } + } + result.length = index2; + return result; + }; + } + ), + /***/ + "./node_modules/core-js/internals/array-includes.js": ( + /*!**********************************************************!*\ + !*** ./node_modules/core-js/internals/array-includes.js ***! + \**********************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var toIndexedObject = __webpack_require__( + /*! ../internals/to-indexed-object */ + "./node_modules/core-js/internals/to-indexed-object.js" + ); + var toLength = __webpack_require__( + /*! ../internals/to-length */ + "./node_modules/core-js/internals/to-length.js" + ); + var toAbsoluteIndex = __webpack_require__( + /*! ../internals/to-absolute-index */ + "./node_modules/core-js/internals/to-absolute-index.js" + ); + module3.exports = function(IS_INCLUDES) { + return function($this, el, fromIndex) { + var O = toIndexedObject($this); + var length = toLength(O.length); + var index2 = toAbsoluteIndex(fromIndex, length); + var value; + if (IS_INCLUDES && el != el) + while (length > index2) { + value = O[index2++]; + if (value != value) + return true; + } + else + for (; length > index2; index2++) + if (IS_INCLUDES || index2 in O) { + if (O[index2] === el) + return IS_INCLUDES || index2 || 0; + } + return !IS_INCLUDES && -1; + }; + }; + } + ), + /***/ + "./node_modules/core-js/internals/bind-context.js": ( + /*!********************************************************!*\ + !*** ./node_modules/core-js/internals/bind-context.js ***! + \********************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var aFunction = __webpack_require__( + /*! ../internals/a-function */ + "./node_modules/core-js/internals/a-function.js" + ); + module3.exports = function(fn, that, length) { + aFunction(fn); + if (that === void 0) + return fn; + switch (length) { + case 0: + return function() { + return fn.call(that); + }; + case 1: + return function(a) { + return fn.call(that, a); + }; + case 2: + return function(a, b) { + return fn.call(that, a, b); + }; + case 3: + return function(a, b, c) { + return fn.call(that, a, b, c); + }; + } + return function() { + return fn.apply(that, arguments); + }; + }; + } + ), + /***/ + "./node_modules/core-js/internals/call-with-safe-iteration-closing.js": ( + /*!****************************************************************************!*\ + !*** ./node_modules/core-js/internals/call-with-safe-iteration-closing.js ***! + \****************************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var anObject = __webpack_require__( + /*! ../internals/an-object */ + "./node_modules/core-js/internals/an-object.js" + ); + module3.exports = function(iterator, fn, value, ENTRIES) { + try { + return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value); + } catch (error) { + var returnMethod = iterator["return"]; + if (returnMethod !== void 0) + anObject(returnMethod.call(iterator)); + throw error; + } + }; + } + ), + /***/ + "./node_modules/core-js/internals/check-correctness-of-iteration.js": ( + /*!**************************************************************************!*\ + !*** ./node_modules/core-js/internals/check-correctness-of-iteration.js ***! + \**************************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var wellKnownSymbol = __webpack_require__( + /*! ../internals/well-known-symbol */ + "./node_modules/core-js/internals/well-known-symbol.js" + ); + var ITERATOR = wellKnownSymbol("iterator"); + var SAFE_CLOSING = false; + try { + var called = 0; + var iteratorWithReturn = { + next: function() { + return { done: !!called++ }; + }, + "return": function() { + SAFE_CLOSING = true; + } + }; + iteratorWithReturn[ITERATOR] = function() { + return this; + }; + Array.from(iteratorWithReturn, function() { + throw 2; + }); + } catch (error) { + } + module3.exports = function(exec, SKIP_CLOSING) { + if (!SKIP_CLOSING && !SAFE_CLOSING) + return false; + var ITERATION_SUPPORT = false; + try { + var object = {}; + object[ITERATOR] = function() { + return { + next: function() { + return { done: ITERATION_SUPPORT = true }; + } + }; + }; + exec(object); + } catch (error) { + } + return ITERATION_SUPPORT; + }; + } + ), + /***/ + "./node_modules/core-js/internals/classof-raw.js": ( + /*!*******************************************************!*\ + !*** ./node_modules/core-js/internals/classof-raw.js ***! + \*******************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3) { + var toString = {}.toString; + module3.exports = function(it) { + return toString.call(it).slice(8, -1); + }; + } + ), + /***/ + "./node_modules/core-js/internals/classof.js": ( + /*!***************************************************!*\ + !*** ./node_modules/core-js/internals/classof.js ***! + \***************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var classofRaw = __webpack_require__( + /*! ../internals/classof-raw */ + "./node_modules/core-js/internals/classof-raw.js" + ); + var wellKnownSymbol = __webpack_require__( + /*! ../internals/well-known-symbol */ + "./node_modules/core-js/internals/well-known-symbol.js" + ); + var TO_STRING_TAG = wellKnownSymbol("toStringTag"); + var CORRECT_ARGUMENTS = classofRaw(function() { + return arguments; + }()) == "Arguments"; + var tryGet = function(it, key2) { + try { + return it[key2]; + } catch (error) { + } + }; + module3.exports = function(it) { + var O, tag2, result; + return it === void 0 ? "Undefined" : it === null ? "Null" : typeof (tag2 = tryGet(O = Object(it), TO_STRING_TAG)) == "string" ? tag2 : CORRECT_ARGUMENTS ? classofRaw(O) : (result = classofRaw(O)) == "Object" && typeof O.callee == "function" ? "Arguments" : result; + }; + } + ), + /***/ + "./node_modules/core-js/internals/copy-constructor-properties.js": ( + /*!***********************************************************************!*\ + !*** ./node_modules/core-js/internals/copy-constructor-properties.js ***! + \***********************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var has = __webpack_require__( + /*! ../internals/has */ + "./node_modules/core-js/internals/has.js" + ); + var ownKeys = __webpack_require__( + /*! ../internals/own-keys */ + "./node_modules/core-js/internals/own-keys.js" + ); + var getOwnPropertyDescriptorModule = __webpack_require__( + /*! ../internals/object-get-own-property-descriptor */ + "./node_modules/core-js/internals/object-get-own-property-descriptor.js" + ); + var definePropertyModule = __webpack_require__( + /*! ../internals/object-define-property */ + "./node_modules/core-js/internals/object-define-property.js" + ); + module3.exports = function(target, source) { + var keys = ownKeys(source); + var defineProperty = definePropertyModule.f; + var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; + for (var i = 0; i < keys.length; i++) { + var key2 = keys[i]; + if (!has(target, key2)) + defineProperty(target, key2, getOwnPropertyDescriptor(source, key2)); + } + }; + } + ), + /***/ + "./node_modules/core-js/internals/correct-prototype-getter.js": ( + /*!********************************************************************!*\ + !*** ./node_modules/core-js/internals/correct-prototype-getter.js ***! + \********************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var fails = __webpack_require__( + /*! ../internals/fails */ + "./node_modules/core-js/internals/fails.js" + ); + module3.exports = !fails(function() { + function F() { + } + F.prototype.constructor = null; + return Object.getPrototypeOf(new F()) !== F.prototype; + }); + } + ), + /***/ + "./node_modules/core-js/internals/create-iterator-constructor.js": ( + /*!***********************************************************************!*\ + !*** ./node_modules/core-js/internals/create-iterator-constructor.js ***! + \***********************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + "use strict"; + var IteratorPrototype = __webpack_require__( + /*! ../internals/iterators-core */ + "./node_modules/core-js/internals/iterators-core.js" + ).IteratorPrototype; + var create = __webpack_require__( + /*! ../internals/object-create */ + "./node_modules/core-js/internals/object-create.js" + ); + var createPropertyDescriptor = __webpack_require__( + /*! ../internals/create-property-descriptor */ + "./node_modules/core-js/internals/create-property-descriptor.js" + ); + var setToStringTag = __webpack_require__( + /*! ../internals/set-to-string-tag */ + "./node_modules/core-js/internals/set-to-string-tag.js" + ); + var Iterators = __webpack_require__( + /*! ../internals/iterators */ + "./node_modules/core-js/internals/iterators.js" + ); + var returnThis = function() { + return this; + }; + module3.exports = function(IteratorConstructor, NAME, next) { + var TO_STRING_TAG = NAME + " Iterator"; + IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(1, next) }); + setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true); + Iterators[TO_STRING_TAG] = returnThis; + return IteratorConstructor; + }; + } + ), + /***/ + "./node_modules/core-js/internals/create-property-descriptor.js": ( + /*!**********************************************************************!*\ + !*** ./node_modules/core-js/internals/create-property-descriptor.js ***! + \**********************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3) { + module3.exports = function(bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value + }; + }; + } + ), + /***/ + "./node_modules/core-js/internals/create-property.js": ( + /*!***********************************************************!*\ + !*** ./node_modules/core-js/internals/create-property.js ***! + \***********************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + "use strict"; + var toPrimitive = __webpack_require__( + /*! ../internals/to-primitive */ + "./node_modules/core-js/internals/to-primitive.js" + ); + var definePropertyModule = __webpack_require__( + /*! ../internals/object-define-property */ + "./node_modules/core-js/internals/object-define-property.js" + ); + var createPropertyDescriptor = __webpack_require__( + /*! ../internals/create-property-descriptor */ + "./node_modules/core-js/internals/create-property-descriptor.js" + ); + module3.exports = function(object, key2, value) { + var propertyKey = toPrimitive(key2); + if (propertyKey in object) + definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value)); + else + object[propertyKey] = value; + }; + } + ), + /***/ + "./node_modules/core-js/internals/define-iterator.js": ( + /*!***********************************************************!*\ + !*** ./node_modules/core-js/internals/define-iterator.js ***! + \***********************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + "use strict"; + var $ = __webpack_require__( + /*! ../internals/export */ + "./node_modules/core-js/internals/export.js" + ); + var createIteratorConstructor = __webpack_require__( + /*! ../internals/create-iterator-constructor */ + "./node_modules/core-js/internals/create-iterator-constructor.js" + ); + var getPrototypeOf = __webpack_require__( + /*! ../internals/object-get-prototype-of */ + "./node_modules/core-js/internals/object-get-prototype-of.js" + ); + var setPrototypeOf = __webpack_require__( + /*! ../internals/object-set-prototype-of */ + "./node_modules/core-js/internals/object-set-prototype-of.js" + ); + var setToStringTag = __webpack_require__( + /*! ../internals/set-to-string-tag */ + "./node_modules/core-js/internals/set-to-string-tag.js" + ); + var hide = __webpack_require__( + /*! ../internals/hide */ + "./node_modules/core-js/internals/hide.js" + ); + var redefine = __webpack_require__( + /*! ../internals/redefine */ + "./node_modules/core-js/internals/redefine.js" + ); + var wellKnownSymbol = __webpack_require__( + /*! ../internals/well-known-symbol */ + "./node_modules/core-js/internals/well-known-symbol.js" + ); + var IS_PURE = __webpack_require__( + /*! ../internals/is-pure */ + "./node_modules/core-js/internals/is-pure.js" + ); + var Iterators = __webpack_require__( + /*! ../internals/iterators */ + "./node_modules/core-js/internals/iterators.js" + ); + var IteratorsCore = __webpack_require__( + /*! ../internals/iterators-core */ + "./node_modules/core-js/internals/iterators-core.js" + ); + var IteratorPrototype = IteratorsCore.IteratorPrototype; + var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS; + var ITERATOR = wellKnownSymbol("iterator"); + var KEYS = "keys"; + var VALUES = "values"; + var ENTRIES = "entries"; + var returnThis = function() { + return this; + }; + module3.exports = function(Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) { + createIteratorConstructor(IteratorConstructor, NAME, next); + var getIterationMethod = function(KIND) { + if (KIND === DEFAULT && defaultIterator) + return defaultIterator; + if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) + return IterablePrototype[KIND]; + switch (KIND) { + case KEYS: + return function keys() { + return new IteratorConstructor(this, KIND); + }; + case VALUES: + return function values() { + return new IteratorConstructor(this, KIND); + }; + case ENTRIES: + return function entries() { + return new IteratorConstructor(this, KIND); + }; + } + return function() { + return new IteratorConstructor(this); + }; + }; + var TO_STRING_TAG = NAME + " Iterator"; + var INCORRECT_VALUES_NAME = false; + var IterablePrototype = Iterable.prototype; + var nativeIterator = IterablePrototype[ITERATOR] || IterablePrototype["@@iterator"] || DEFAULT && IterablePrototype[DEFAULT]; + var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT); + var anyNativeIterator = NAME == "Array" ? IterablePrototype.entries || nativeIterator : nativeIterator; + var CurrentIteratorPrototype, methods, KEY; + if (anyNativeIterator) { + CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable())); + if (IteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) { + if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) { + if (setPrototypeOf) { + setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype); + } else if (typeof CurrentIteratorPrototype[ITERATOR] != "function") { + hide(CurrentIteratorPrototype, ITERATOR, returnThis); + } + } + setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true); + if (IS_PURE) + Iterators[TO_STRING_TAG] = returnThis; + } + } + if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) { + INCORRECT_VALUES_NAME = true; + defaultIterator = function values() { + return nativeIterator.call(this); + }; + } + if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) { + hide(IterablePrototype, ITERATOR, defaultIterator); + } + Iterators[NAME] = defaultIterator; + if (DEFAULT) { + methods = { + values: getIterationMethod(VALUES), + keys: IS_SET ? defaultIterator : getIterationMethod(KEYS), + entries: getIterationMethod(ENTRIES) + }; + if (FORCED) + for (KEY in methods) { + if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) { + redefine(IterablePrototype, KEY, methods[KEY]); + } + } + else + $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods); + } + return methods; + }; + } + ), + /***/ + "./node_modules/core-js/internals/descriptors.js": ( + /*!*******************************************************!*\ + !*** ./node_modules/core-js/internals/descriptors.js ***! + \*******************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var fails = __webpack_require__( + /*! ../internals/fails */ + "./node_modules/core-js/internals/fails.js" + ); + module3.exports = !fails(function() { + return Object.defineProperty({}, "a", { get: function() { + return 7; + } }).a != 7; + }); + } + ), + /***/ + "./node_modules/core-js/internals/document-create-element.js": ( + /*!*******************************************************************!*\ + !*** ./node_modules/core-js/internals/document-create-element.js ***! + \*******************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var global2 = __webpack_require__( + /*! ../internals/global */ + "./node_modules/core-js/internals/global.js" + ); + var isObject = __webpack_require__( + /*! ../internals/is-object */ + "./node_modules/core-js/internals/is-object.js" + ); + var document2 = global2.document; + var exist = isObject(document2) && isObject(document2.createElement); + module3.exports = function(it) { + return exist ? document2.createElement(it) : {}; + }; + } + ), + /***/ + "./node_modules/core-js/internals/enum-bug-keys.js": ( + /*!*********************************************************!*\ + !*** ./node_modules/core-js/internals/enum-bug-keys.js ***! + \*********************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3) { + module3.exports = [ + "constructor", + "hasOwnProperty", + "isPrototypeOf", + "propertyIsEnumerable", + "toLocaleString", + "toString", + "valueOf" + ]; + } + ), + /***/ + "./node_modules/core-js/internals/export.js": ( + /*!**************************************************!*\ + !*** ./node_modules/core-js/internals/export.js ***! + \**************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var global2 = __webpack_require__( + /*! ../internals/global */ + "./node_modules/core-js/internals/global.js" + ); + var getOwnPropertyDescriptor = __webpack_require__( + /*! ../internals/object-get-own-property-descriptor */ + "./node_modules/core-js/internals/object-get-own-property-descriptor.js" + ).f; + var hide = __webpack_require__( + /*! ../internals/hide */ + "./node_modules/core-js/internals/hide.js" + ); + var redefine = __webpack_require__( + /*! ../internals/redefine */ + "./node_modules/core-js/internals/redefine.js" + ); + var setGlobal = __webpack_require__( + /*! ../internals/set-global */ + "./node_modules/core-js/internals/set-global.js" + ); + var copyConstructorProperties = __webpack_require__( + /*! ../internals/copy-constructor-properties */ + "./node_modules/core-js/internals/copy-constructor-properties.js" + ); + var isForced = __webpack_require__( + /*! ../internals/is-forced */ + "./node_modules/core-js/internals/is-forced.js" + ); + module3.exports = function(options, source) { + var TARGET = options.target; + var GLOBAL = options.global; + var STATIC = options.stat; + var FORCED, target, key2, targetProperty, sourceProperty, descriptor; + if (GLOBAL) { + target = global2; + } else if (STATIC) { + target = global2[TARGET] || setGlobal(TARGET, {}); + } else { + target = (global2[TARGET] || {}).prototype; + } + if (target) + for (key2 in source) { + sourceProperty = source[key2]; + if (options.noTargetGet) { + descriptor = getOwnPropertyDescriptor(target, key2); + targetProperty = descriptor && descriptor.value; + } else + targetProperty = target[key2]; + FORCED = isForced(GLOBAL ? key2 : TARGET + (STATIC ? "." : "#") + key2, options.forced); + if (!FORCED && targetProperty !== void 0) { + if (typeof sourceProperty === typeof targetProperty) + continue; + copyConstructorProperties(sourceProperty, targetProperty); + } + if (options.sham || targetProperty && targetProperty.sham) { + hide(sourceProperty, "sham", true); + } + redefine(target, key2, sourceProperty, options); + } + }; + } + ), + /***/ + "./node_modules/core-js/internals/fails.js": ( + /*!*************************************************!*\ + !*** ./node_modules/core-js/internals/fails.js ***! + \*************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3) { + module3.exports = function(exec) { + try { + return !!exec(); + } catch (error) { + return true; + } + }; + } + ), + /***/ + "./node_modules/core-js/internals/function-to-string.js": ( + /*!**************************************************************!*\ + !*** ./node_modules/core-js/internals/function-to-string.js ***! + \**************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var shared = __webpack_require__( + /*! ../internals/shared */ + "./node_modules/core-js/internals/shared.js" + ); + module3.exports = shared("native-function-to-string", Function.toString); + } + ), + /***/ + "./node_modules/core-js/internals/get-iterator-method.js": ( + /*!***************************************************************!*\ + !*** ./node_modules/core-js/internals/get-iterator-method.js ***! + \***************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var classof = __webpack_require__( + /*! ../internals/classof */ + "./node_modules/core-js/internals/classof.js" + ); + var Iterators = __webpack_require__( + /*! ../internals/iterators */ + "./node_modules/core-js/internals/iterators.js" + ); + var wellKnownSymbol = __webpack_require__( + /*! ../internals/well-known-symbol */ + "./node_modules/core-js/internals/well-known-symbol.js" + ); + var ITERATOR = wellKnownSymbol("iterator"); + module3.exports = function(it) { + if (it != void 0) + return it[ITERATOR] || it["@@iterator"] || Iterators[classof(it)]; + }; + } + ), + /***/ + "./node_modules/core-js/internals/global.js": ( + /*!**************************************************!*\ + !*** ./node_modules/core-js/internals/global.js ***! + \**************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + (function(global2) { + var O = "object"; + var check = function(it) { + return it && it.Math == Math && it; + }; + module3.exports = // eslint-disable-next-line no-undef + check(typeof globalThis == O && globalThis) || check(typeof window == O && window) || check(typeof self == O && self) || check(typeof global2 == O && global2) || // eslint-disable-next-line no-new-func + Function("return this")(); + }).call(this, __webpack_require__( + /*! ./../../webpack/buildin/global.js */ + "./node_modules/webpack/buildin/global.js" + )); + } + ), + /***/ + "./node_modules/core-js/internals/has.js": ( + /*!***********************************************!*\ + !*** ./node_modules/core-js/internals/has.js ***! + \***********************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3) { + var hasOwnProperty = {}.hasOwnProperty; + module3.exports = function(it, key2) { + return hasOwnProperty.call(it, key2); + }; + } + ), + /***/ + "./node_modules/core-js/internals/hidden-keys.js": ( + /*!*******************************************************!*\ + !*** ./node_modules/core-js/internals/hidden-keys.js ***! + \*******************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3) { + module3.exports = {}; + } + ), + /***/ + "./node_modules/core-js/internals/hide.js": ( + /*!************************************************!*\ + !*** ./node_modules/core-js/internals/hide.js ***! + \************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var DESCRIPTORS = __webpack_require__( + /*! ../internals/descriptors */ + "./node_modules/core-js/internals/descriptors.js" + ); + var definePropertyModule = __webpack_require__( + /*! ../internals/object-define-property */ + "./node_modules/core-js/internals/object-define-property.js" + ); + var createPropertyDescriptor = __webpack_require__( + /*! ../internals/create-property-descriptor */ + "./node_modules/core-js/internals/create-property-descriptor.js" + ); + module3.exports = DESCRIPTORS ? function(object, key2, value) { + return definePropertyModule.f(object, key2, createPropertyDescriptor(1, value)); + } : function(object, key2, value) { + object[key2] = value; + return object; + }; + } + ), + /***/ + "./node_modules/core-js/internals/html.js": ( + /*!************************************************!*\ + !*** ./node_modules/core-js/internals/html.js ***! + \************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var global2 = __webpack_require__( + /*! ../internals/global */ + "./node_modules/core-js/internals/global.js" + ); + var document2 = global2.document; + module3.exports = document2 && document2.documentElement; + } + ), + /***/ + "./node_modules/core-js/internals/ie8-dom-define.js": ( + /*!**********************************************************!*\ + !*** ./node_modules/core-js/internals/ie8-dom-define.js ***! + \**********************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var DESCRIPTORS = __webpack_require__( + /*! ../internals/descriptors */ + "./node_modules/core-js/internals/descriptors.js" + ); + var fails = __webpack_require__( + /*! ../internals/fails */ + "./node_modules/core-js/internals/fails.js" + ); + var createElement = __webpack_require__( + /*! ../internals/document-create-element */ + "./node_modules/core-js/internals/document-create-element.js" + ); + module3.exports = !DESCRIPTORS && !fails(function() { + return Object.defineProperty(createElement("div"), "a", { + get: function() { + return 7; + } + }).a != 7; + }); + } + ), + /***/ + "./node_modules/core-js/internals/indexed-object.js": ( + /*!**********************************************************!*\ + !*** ./node_modules/core-js/internals/indexed-object.js ***! + \**********************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var fails = __webpack_require__( + /*! ../internals/fails */ + "./node_modules/core-js/internals/fails.js" + ); + var classof = __webpack_require__( + /*! ../internals/classof-raw */ + "./node_modules/core-js/internals/classof-raw.js" + ); + var split = "".split; + module3.exports = fails(function() { + return !Object("z").propertyIsEnumerable(0); + }) ? function(it) { + return classof(it) == "String" ? split.call(it, "") : Object(it); + } : Object; + } + ), + /***/ + "./node_modules/core-js/internals/internal-state.js": ( + /*!**********************************************************!*\ + !*** ./node_modules/core-js/internals/internal-state.js ***! + \**********************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var NATIVE_WEAK_MAP = __webpack_require__( + /*! ../internals/native-weak-map */ + "./node_modules/core-js/internals/native-weak-map.js" + ); + var global2 = __webpack_require__( + /*! ../internals/global */ + "./node_modules/core-js/internals/global.js" + ); + var isObject = __webpack_require__( + /*! ../internals/is-object */ + "./node_modules/core-js/internals/is-object.js" + ); + var hide = __webpack_require__( + /*! ../internals/hide */ + "./node_modules/core-js/internals/hide.js" + ); + var objectHas = __webpack_require__( + /*! ../internals/has */ + "./node_modules/core-js/internals/has.js" + ); + var sharedKey = __webpack_require__( + /*! ../internals/shared-key */ + "./node_modules/core-js/internals/shared-key.js" + ); + var hiddenKeys = __webpack_require__( + /*! ../internals/hidden-keys */ + "./node_modules/core-js/internals/hidden-keys.js" + ); + var WeakMap2 = global2.WeakMap; + var set, get, has; + var enforce = function(it) { + return has(it) ? get(it) : set(it, {}); + }; + var getterFor = function(TYPE) { + return function(it) { + var state; + if (!isObject(it) || (state = get(it)).type !== TYPE) { + throw TypeError("Incompatible receiver, " + TYPE + " required"); + } + return state; + }; + }; + if (NATIVE_WEAK_MAP) { + var store = new WeakMap2(); + var wmget = store.get; + var wmhas = store.has; + var wmset = store.set; + set = function(it, metadata) { + wmset.call(store, it, metadata); + return metadata; + }; + get = function(it) { + return wmget.call(store, it) || {}; + }; + has = function(it) { + return wmhas.call(store, it); + }; + } else { + var STATE = sharedKey("state"); + hiddenKeys[STATE] = true; + set = function(it, metadata) { + hide(it, STATE, metadata); + return metadata; + }; + get = function(it) { + return objectHas(it, STATE) ? it[STATE] : {}; + }; + has = function(it) { + return objectHas(it, STATE); + }; + } + module3.exports = { + set, + get, + has, + enforce, + getterFor + }; + } + ), + /***/ + "./node_modules/core-js/internals/is-array-iterator-method.js": ( + /*!********************************************************************!*\ + !*** ./node_modules/core-js/internals/is-array-iterator-method.js ***! + \********************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var wellKnownSymbol = __webpack_require__( + /*! ../internals/well-known-symbol */ + "./node_modules/core-js/internals/well-known-symbol.js" + ); + var Iterators = __webpack_require__( + /*! ../internals/iterators */ + "./node_modules/core-js/internals/iterators.js" + ); + var ITERATOR = wellKnownSymbol("iterator"); + var ArrayPrototype = Array.prototype; + module3.exports = function(it) { + return it !== void 0 && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it); + }; + } + ), + /***/ + "./node_modules/core-js/internals/is-forced.js": ( + /*!*****************************************************!*\ + !*** ./node_modules/core-js/internals/is-forced.js ***! + \*****************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var fails = __webpack_require__( + /*! ../internals/fails */ + "./node_modules/core-js/internals/fails.js" + ); + var replacement = /#|\.prototype\./; + var isForced = function(feature, detection) { + var value = data[normalize2(feature)]; + return value == POLYFILL ? true : value == NATIVE ? false : typeof detection == "function" ? fails(detection) : !!detection; + }; + var normalize2 = isForced.normalize = function(string) { + return String(string).replace(replacement, ".").toLowerCase(); + }; + var data = isForced.data = {}; + var NATIVE = isForced.NATIVE = "N"; + var POLYFILL = isForced.POLYFILL = "P"; + module3.exports = isForced; + } + ), + /***/ + "./node_modules/core-js/internals/is-object.js": ( + /*!*****************************************************!*\ + !*** ./node_modules/core-js/internals/is-object.js ***! + \*****************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3) { + module3.exports = function(it) { + return typeof it === "object" ? it !== null : typeof it === "function"; + }; + } + ), + /***/ + "./node_modules/core-js/internals/is-pure.js": ( + /*!***************************************************!*\ + !*** ./node_modules/core-js/internals/is-pure.js ***! + \***************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3) { + module3.exports = false; + } + ), + /***/ + "./node_modules/core-js/internals/iterators-core.js": ( + /*!**********************************************************!*\ + !*** ./node_modules/core-js/internals/iterators-core.js ***! + \**********************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + "use strict"; + var getPrototypeOf = __webpack_require__( + /*! ../internals/object-get-prototype-of */ + "./node_modules/core-js/internals/object-get-prototype-of.js" + ); + var hide = __webpack_require__( + /*! ../internals/hide */ + "./node_modules/core-js/internals/hide.js" + ); + var has = __webpack_require__( + /*! ../internals/has */ + "./node_modules/core-js/internals/has.js" + ); + var wellKnownSymbol = __webpack_require__( + /*! ../internals/well-known-symbol */ + "./node_modules/core-js/internals/well-known-symbol.js" + ); + var IS_PURE = __webpack_require__( + /*! ../internals/is-pure */ + "./node_modules/core-js/internals/is-pure.js" + ); + var ITERATOR = wellKnownSymbol("iterator"); + var BUGGY_SAFARI_ITERATORS = false; + var returnThis = function() { + return this; + }; + var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator; + if ([].keys) { + arrayIterator = [].keys(); + if (!("next" in arrayIterator)) + BUGGY_SAFARI_ITERATORS = true; + else { + PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator)); + if (PrototypeOfArrayIteratorPrototype !== Object.prototype) + IteratorPrototype = PrototypeOfArrayIteratorPrototype; + } + } + if (IteratorPrototype == void 0) + IteratorPrototype = {}; + if (!IS_PURE && !has(IteratorPrototype, ITERATOR)) + hide(IteratorPrototype, ITERATOR, returnThis); + module3.exports = { + IteratorPrototype, + BUGGY_SAFARI_ITERATORS + }; + } + ), + /***/ + "./node_modules/core-js/internals/iterators.js": ( + /*!*****************************************************!*\ + !*** ./node_modules/core-js/internals/iterators.js ***! + \*****************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3) { + module3.exports = {}; + } + ), + /***/ + "./node_modules/core-js/internals/native-symbol.js": ( + /*!*********************************************************!*\ + !*** ./node_modules/core-js/internals/native-symbol.js ***! + \*********************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var fails = __webpack_require__( + /*! ../internals/fails */ + "./node_modules/core-js/internals/fails.js" + ); + module3.exports = !!Object.getOwnPropertySymbols && !fails(function() { + return !String(Symbol()); + }); + } + ), + /***/ + "./node_modules/core-js/internals/native-weak-map.js": ( + /*!***********************************************************!*\ + !*** ./node_modules/core-js/internals/native-weak-map.js ***! + \***********************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var global2 = __webpack_require__( + /*! ../internals/global */ + "./node_modules/core-js/internals/global.js" + ); + var nativeFunctionToString = __webpack_require__( + /*! ../internals/function-to-string */ + "./node_modules/core-js/internals/function-to-string.js" + ); + var WeakMap2 = global2.WeakMap; + module3.exports = typeof WeakMap2 === "function" && /native code/.test(nativeFunctionToString.call(WeakMap2)); + } + ), + /***/ + "./node_modules/core-js/internals/object-create.js": ( + /*!*********************************************************!*\ + !*** ./node_modules/core-js/internals/object-create.js ***! + \*********************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var anObject = __webpack_require__( + /*! ../internals/an-object */ + "./node_modules/core-js/internals/an-object.js" + ); + var defineProperties = __webpack_require__( + /*! ../internals/object-define-properties */ + "./node_modules/core-js/internals/object-define-properties.js" + ); + var enumBugKeys = __webpack_require__( + /*! ../internals/enum-bug-keys */ + "./node_modules/core-js/internals/enum-bug-keys.js" + ); + var hiddenKeys = __webpack_require__( + /*! ../internals/hidden-keys */ + "./node_modules/core-js/internals/hidden-keys.js" + ); + var html2 = __webpack_require__( + /*! ../internals/html */ + "./node_modules/core-js/internals/html.js" + ); + var documentCreateElement = __webpack_require__( + /*! ../internals/document-create-element */ + "./node_modules/core-js/internals/document-create-element.js" + ); + var sharedKey = __webpack_require__( + /*! ../internals/shared-key */ + "./node_modules/core-js/internals/shared-key.js" + ); + var IE_PROTO = sharedKey("IE_PROTO"); + var PROTOTYPE = "prototype"; + var Empty = function() { + }; + var createDict = function() { + var iframe = documentCreateElement("iframe"); + var length = enumBugKeys.length; + var lt = "<"; + var script = "script"; + var gt = ">"; + var js = "java" + script + ":"; + var iframeDocument; + iframe.style.display = "none"; + html2.appendChild(iframe); + iframe.src = String(js); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(lt + script + gt + "document.F=Object" + lt + "/" + script + gt); + iframeDocument.close(); + createDict = iframeDocument.F; + while (length--) + delete createDict[PROTOTYPE][enumBugKeys[length]]; + return createDict(); + }; + module3.exports = Object.create || function create(O, Properties) { + var result; + if (O !== null) { + Empty[PROTOTYPE] = anObject(O); + result = new Empty(); + Empty[PROTOTYPE] = null; + result[IE_PROTO] = O; + } else + result = createDict(); + return Properties === void 0 ? result : defineProperties(result, Properties); + }; + hiddenKeys[IE_PROTO] = true; + } + ), + /***/ + "./node_modules/core-js/internals/object-define-properties.js": ( + /*!********************************************************************!*\ + !*** ./node_modules/core-js/internals/object-define-properties.js ***! + \********************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var DESCRIPTORS = __webpack_require__( + /*! ../internals/descriptors */ + "./node_modules/core-js/internals/descriptors.js" + ); + var definePropertyModule = __webpack_require__( + /*! ../internals/object-define-property */ + "./node_modules/core-js/internals/object-define-property.js" + ); + var anObject = __webpack_require__( + /*! ../internals/an-object */ + "./node_modules/core-js/internals/an-object.js" + ); + var objectKeys = __webpack_require__( + /*! ../internals/object-keys */ + "./node_modules/core-js/internals/object-keys.js" + ); + module3.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) { + anObject(O); + var keys = objectKeys(Properties); + var length = keys.length; + var i = 0; + var key2; + while (length > i) + definePropertyModule.f(O, key2 = keys[i++], Properties[key2]); + return O; + }; + } + ), + /***/ + "./node_modules/core-js/internals/object-define-property.js": ( + /*!******************************************************************!*\ + !*** ./node_modules/core-js/internals/object-define-property.js ***! + \******************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var DESCRIPTORS = __webpack_require__( + /*! ../internals/descriptors */ + "./node_modules/core-js/internals/descriptors.js" + ); + var IE8_DOM_DEFINE = __webpack_require__( + /*! ../internals/ie8-dom-define */ + "./node_modules/core-js/internals/ie8-dom-define.js" + ); + var anObject = __webpack_require__( + /*! ../internals/an-object */ + "./node_modules/core-js/internals/an-object.js" + ); + var toPrimitive = __webpack_require__( + /*! ../internals/to-primitive */ + "./node_modules/core-js/internals/to-primitive.js" + ); + var nativeDefineProperty = Object.defineProperty; + exports3.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, Attributes) { + anObject(O); + P = toPrimitive(P, true); + anObject(Attributes); + if (IE8_DOM_DEFINE) + try { + return nativeDefineProperty(O, P, Attributes); + } catch (error) { + } + if ("get" in Attributes || "set" in Attributes) + throw TypeError("Accessors not supported"); + if ("value" in Attributes) + O[P] = Attributes.value; + return O; + }; + } + ), + /***/ + "./node_modules/core-js/internals/object-get-own-property-descriptor.js": ( + /*!******************************************************************************!*\ + !*** ./node_modules/core-js/internals/object-get-own-property-descriptor.js ***! + \******************************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var DESCRIPTORS = __webpack_require__( + /*! ../internals/descriptors */ + "./node_modules/core-js/internals/descriptors.js" + ); + var propertyIsEnumerableModule = __webpack_require__( + /*! ../internals/object-property-is-enumerable */ + "./node_modules/core-js/internals/object-property-is-enumerable.js" + ); + var createPropertyDescriptor = __webpack_require__( + /*! ../internals/create-property-descriptor */ + "./node_modules/core-js/internals/create-property-descriptor.js" + ); + var toIndexedObject = __webpack_require__( + /*! ../internals/to-indexed-object */ + "./node_modules/core-js/internals/to-indexed-object.js" + ); + var toPrimitive = __webpack_require__( + /*! ../internals/to-primitive */ + "./node_modules/core-js/internals/to-primitive.js" + ); + var has = __webpack_require__( + /*! ../internals/has */ + "./node_modules/core-js/internals/has.js" + ); + var IE8_DOM_DEFINE = __webpack_require__( + /*! ../internals/ie8-dom-define */ + "./node_modules/core-js/internals/ie8-dom-define.js" + ); + var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + exports3.f = DESCRIPTORS ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) { + O = toIndexedObject(O); + P = toPrimitive(P, true); + if (IE8_DOM_DEFINE) + try { + return nativeGetOwnPropertyDescriptor(O, P); + } catch (error) { + } + if (has(O, P)) + return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]); + }; + } + ), + /***/ + "./node_modules/core-js/internals/object-get-own-property-names.js": ( + /*!*************************************************************************!*\ + !*** ./node_modules/core-js/internals/object-get-own-property-names.js ***! + \*************************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var internalObjectKeys = __webpack_require__( + /*! ../internals/object-keys-internal */ + "./node_modules/core-js/internals/object-keys-internal.js" + ); + var enumBugKeys = __webpack_require__( + /*! ../internals/enum-bug-keys */ + "./node_modules/core-js/internals/enum-bug-keys.js" + ); + var hiddenKeys = enumBugKeys.concat("length", "prototype"); + exports3.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { + return internalObjectKeys(O, hiddenKeys); + }; + } + ), + /***/ + "./node_modules/core-js/internals/object-get-own-property-symbols.js": ( + /*!***************************************************************************!*\ + !*** ./node_modules/core-js/internals/object-get-own-property-symbols.js ***! + \***************************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3) { + exports3.f = Object.getOwnPropertySymbols; + } + ), + /***/ + "./node_modules/core-js/internals/object-get-prototype-of.js": ( + /*!*******************************************************************!*\ + !*** ./node_modules/core-js/internals/object-get-prototype-of.js ***! + \*******************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var has = __webpack_require__( + /*! ../internals/has */ + "./node_modules/core-js/internals/has.js" + ); + var toObject = __webpack_require__( + /*! ../internals/to-object */ + "./node_modules/core-js/internals/to-object.js" + ); + var sharedKey = __webpack_require__( + /*! ../internals/shared-key */ + "./node_modules/core-js/internals/shared-key.js" + ); + var CORRECT_PROTOTYPE_GETTER = __webpack_require__( + /*! ../internals/correct-prototype-getter */ + "./node_modules/core-js/internals/correct-prototype-getter.js" + ); + var IE_PROTO = sharedKey("IE_PROTO"); + var ObjectPrototype = Object.prototype; + module3.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function(O) { + O = toObject(O); + if (has(O, IE_PROTO)) + return O[IE_PROTO]; + if (typeof O.constructor == "function" && O instanceof O.constructor) { + return O.constructor.prototype; + } + return O instanceof Object ? ObjectPrototype : null; + }; + } + ), + /***/ + "./node_modules/core-js/internals/object-keys-internal.js": ( + /*!****************************************************************!*\ + !*** ./node_modules/core-js/internals/object-keys-internal.js ***! + \****************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var has = __webpack_require__( + /*! ../internals/has */ + "./node_modules/core-js/internals/has.js" + ); + var toIndexedObject = __webpack_require__( + /*! ../internals/to-indexed-object */ + "./node_modules/core-js/internals/to-indexed-object.js" + ); + var arrayIncludes = __webpack_require__( + /*! ../internals/array-includes */ + "./node_modules/core-js/internals/array-includes.js" + ); + var hiddenKeys = __webpack_require__( + /*! ../internals/hidden-keys */ + "./node_modules/core-js/internals/hidden-keys.js" + ); + var arrayIndexOf = arrayIncludes(false); + module3.exports = function(object, names) { + var O = toIndexedObject(object); + var i = 0; + var result = []; + var key2; + for (key2 in O) + !has(hiddenKeys, key2) && has(O, key2) && result.push(key2); + while (names.length > i) + if (has(O, key2 = names[i++])) { + ~arrayIndexOf(result, key2) || result.push(key2); + } + return result; + }; + } + ), + /***/ + "./node_modules/core-js/internals/object-keys.js": ( + /*!*******************************************************!*\ + !*** ./node_modules/core-js/internals/object-keys.js ***! + \*******************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var internalObjectKeys = __webpack_require__( + /*! ../internals/object-keys-internal */ + "./node_modules/core-js/internals/object-keys-internal.js" + ); + var enumBugKeys = __webpack_require__( + /*! ../internals/enum-bug-keys */ + "./node_modules/core-js/internals/enum-bug-keys.js" + ); + module3.exports = Object.keys || function keys(O) { + return internalObjectKeys(O, enumBugKeys); + }; + } + ), + /***/ + "./node_modules/core-js/internals/object-property-is-enumerable.js": ( + /*!*************************************************************************!*\ + !*** ./node_modules/core-js/internals/object-property-is-enumerable.js ***! + \*************************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + "use strict"; + var nativePropertyIsEnumerable = {}.propertyIsEnumerable; + var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + var NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1); + exports3.f = NASHORN_BUG ? function propertyIsEnumerable(V) { + var descriptor = getOwnPropertyDescriptor(this, V); + return !!descriptor && descriptor.enumerable; + } : nativePropertyIsEnumerable; + } + ), + /***/ + "./node_modules/core-js/internals/object-set-prototype-of.js": ( + /*!*******************************************************************!*\ + !*** ./node_modules/core-js/internals/object-set-prototype-of.js ***! + \*******************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var validateSetPrototypeOfArguments = __webpack_require__( + /*! ../internals/validate-set-prototype-of-arguments */ + "./node_modules/core-js/internals/validate-set-prototype-of-arguments.js" + ); + module3.exports = Object.setPrototypeOf || ("__proto__" in {} ? function() { + var correctSetter = false; + var test = {}; + var setter; + try { + setter = Object.getOwnPropertyDescriptor(Object.prototype, "__proto__").set; + setter.call(test, []); + correctSetter = test instanceof Array; + } catch (error) { + } + return function setPrototypeOf(O, proto) { + validateSetPrototypeOfArguments(O, proto); + if (correctSetter) + setter.call(O, proto); + else + O.__proto__ = proto; + return O; + }; + }() : void 0); + } + ), + /***/ + "./node_modules/core-js/internals/own-keys.js": ( + /*!****************************************************!*\ + !*** ./node_modules/core-js/internals/own-keys.js ***! + \****************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var global2 = __webpack_require__( + /*! ../internals/global */ + "./node_modules/core-js/internals/global.js" + ); + var getOwnPropertyNamesModule = __webpack_require__( + /*! ../internals/object-get-own-property-names */ + "./node_modules/core-js/internals/object-get-own-property-names.js" + ); + var getOwnPropertySymbolsModule = __webpack_require__( + /*! ../internals/object-get-own-property-symbols */ + "./node_modules/core-js/internals/object-get-own-property-symbols.js" + ); + var anObject = __webpack_require__( + /*! ../internals/an-object */ + "./node_modules/core-js/internals/an-object.js" + ); + var Reflect2 = global2.Reflect; + module3.exports = Reflect2 && Reflect2.ownKeys || function ownKeys(it) { + var keys = getOwnPropertyNamesModule.f(anObject(it)); + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys; + }; + } + ), + /***/ + "./node_modules/core-js/internals/path.js": ( + /*!************************************************!*\ + !*** ./node_modules/core-js/internals/path.js ***! + \************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + module3.exports = __webpack_require__( + /*! ../internals/global */ + "./node_modules/core-js/internals/global.js" + ); + } + ), + /***/ + "./node_modules/core-js/internals/redefine.js": ( + /*!****************************************************!*\ + !*** ./node_modules/core-js/internals/redefine.js ***! + \****************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var global2 = __webpack_require__( + /*! ../internals/global */ + "./node_modules/core-js/internals/global.js" + ); + var shared = __webpack_require__( + /*! ../internals/shared */ + "./node_modules/core-js/internals/shared.js" + ); + var hide = __webpack_require__( + /*! ../internals/hide */ + "./node_modules/core-js/internals/hide.js" + ); + var has = __webpack_require__( + /*! ../internals/has */ + "./node_modules/core-js/internals/has.js" + ); + var setGlobal = __webpack_require__( + /*! ../internals/set-global */ + "./node_modules/core-js/internals/set-global.js" + ); + var nativeFunctionToString = __webpack_require__( + /*! ../internals/function-to-string */ + "./node_modules/core-js/internals/function-to-string.js" + ); + var InternalStateModule = __webpack_require__( + /*! ../internals/internal-state */ + "./node_modules/core-js/internals/internal-state.js" + ); + var getInternalState = InternalStateModule.get; + var enforceInternalState = InternalStateModule.enforce; + var TEMPLATE = String(nativeFunctionToString).split("toString"); + shared("inspectSource", function(it) { + return nativeFunctionToString.call(it); + }); + (module3.exports = function(O, key2, value, options) { + var unsafe = options ? !!options.unsafe : false; + var simple2 = options ? !!options.enumerable : false; + var noTargetGet = options ? !!options.noTargetGet : false; + if (typeof value == "function") { + if (typeof key2 == "string" && !has(value, "name")) + hide(value, "name", key2); + enforceInternalState(value).source = TEMPLATE.join(typeof key2 == "string" ? key2 : ""); + } + if (O === global2) { + if (simple2) + O[key2] = value; + else + setGlobal(key2, value); + return; + } else if (!unsafe) { + delete O[key2]; + } else if (!noTargetGet && O[key2]) { + simple2 = true; + } + if (simple2) + O[key2] = value; + else + hide(O, key2, value); + })(Function.prototype, "toString", function toString() { + return typeof this == "function" && getInternalState(this).source || nativeFunctionToString.call(this); + }); + } + ), + /***/ + "./node_modules/core-js/internals/require-object-coercible.js": ( + /*!********************************************************************!*\ + !*** ./node_modules/core-js/internals/require-object-coercible.js ***! + \********************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3) { + module3.exports = function(it) { + if (it == void 0) + throw TypeError("Can't call method on " + it); + return it; + }; + } + ), + /***/ + "./node_modules/core-js/internals/set-global.js": ( + /*!******************************************************!*\ + !*** ./node_modules/core-js/internals/set-global.js ***! + \******************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var global2 = __webpack_require__( + /*! ../internals/global */ + "./node_modules/core-js/internals/global.js" + ); + var hide = __webpack_require__( + /*! ../internals/hide */ + "./node_modules/core-js/internals/hide.js" + ); + module3.exports = function(key2, value) { + try { + hide(global2, key2, value); + } catch (error) { + global2[key2] = value; + } + return value; + }; + } + ), + /***/ + "./node_modules/core-js/internals/set-to-string-tag.js": ( + /*!*************************************************************!*\ + !*** ./node_modules/core-js/internals/set-to-string-tag.js ***! + \*************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var defineProperty = __webpack_require__( + /*! ../internals/object-define-property */ + "./node_modules/core-js/internals/object-define-property.js" + ).f; + var has = __webpack_require__( + /*! ../internals/has */ + "./node_modules/core-js/internals/has.js" + ); + var wellKnownSymbol = __webpack_require__( + /*! ../internals/well-known-symbol */ + "./node_modules/core-js/internals/well-known-symbol.js" + ); + var TO_STRING_TAG = wellKnownSymbol("toStringTag"); + module3.exports = function(it, TAG, STATIC) { + if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) { + defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG }); + } + }; + } + ), + /***/ + "./node_modules/core-js/internals/shared-key.js": ( + /*!******************************************************!*\ + !*** ./node_modules/core-js/internals/shared-key.js ***! + \******************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var shared = __webpack_require__( + /*! ../internals/shared */ + "./node_modules/core-js/internals/shared.js" + ); + var uid = __webpack_require__( + /*! ../internals/uid */ + "./node_modules/core-js/internals/uid.js" + ); + var keys = shared("keys"); + module3.exports = function(key2) { + return keys[key2] || (keys[key2] = uid(key2)); + }; + } + ), + /***/ + "./node_modules/core-js/internals/shared.js": ( + /*!**************************************************!*\ + !*** ./node_modules/core-js/internals/shared.js ***! + \**************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var global2 = __webpack_require__( + /*! ../internals/global */ + "./node_modules/core-js/internals/global.js" + ); + var setGlobal = __webpack_require__( + /*! ../internals/set-global */ + "./node_modules/core-js/internals/set-global.js" + ); + var IS_PURE = __webpack_require__( + /*! ../internals/is-pure */ + "./node_modules/core-js/internals/is-pure.js" + ); + var SHARED = "__core-js_shared__"; + var store = global2[SHARED] || setGlobal(SHARED, {}); + (module3.exports = function(key2, value) { + return store[key2] || (store[key2] = value !== void 0 ? value : {}); + })("versions", []).push({ + version: "3.1.3", + mode: IS_PURE ? "pure" : "global", + copyright: "\xA9 2019 Denis Pushkarev (zloirock.ru)" + }); + } + ), + /***/ + "./node_modules/core-js/internals/string-at.js": ( + /*!*****************************************************!*\ + !*** ./node_modules/core-js/internals/string-at.js ***! + \*****************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var toInteger = __webpack_require__( + /*! ../internals/to-integer */ + "./node_modules/core-js/internals/to-integer.js" + ); + var requireObjectCoercible = __webpack_require__( + /*! ../internals/require-object-coercible */ + "./node_modules/core-js/internals/require-object-coercible.js" + ); + module3.exports = function(that, pos, CONVERT_TO_STRING) { + var S = String(requireObjectCoercible(that)); + var position = toInteger(pos); + var size = S.length; + var first2, second; + if (position < 0 || position >= size) + return CONVERT_TO_STRING ? "" : void 0; + first2 = S.charCodeAt(position); + return first2 < 55296 || first2 > 56319 || position + 1 === size || (second = S.charCodeAt(position + 1)) < 56320 || second > 57343 ? CONVERT_TO_STRING ? S.charAt(position) : first2 : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first2 - 55296 << 10) + (second - 56320) + 65536; + }; + } + ), + /***/ + "./node_modules/core-js/internals/to-absolute-index.js": ( + /*!*************************************************************!*\ + !*** ./node_modules/core-js/internals/to-absolute-index.js ***! + \*************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var toInteger = __webpack_require__( + /*! ../internals/to-integer */ + "./node_modules/core-js/internals/to-integer.js" + ); + var max = Math.max; + var min = Math.min; + module3.exports = function(index2, length) { + var integer = toInteger(index2); + return integer < 0 ? max(integer + length, 0) : min(integer, length); + }; + } + ), + /***/ + "./node_modules/core-js/internals/to-indexed-object.js": ( + /*!*************************************************************!*\ + !*** ./node_modules/core-js/internals/to-indexed-object.js ***! + \*************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var IndexedObject = __webpack_require__( + /*! ../internals/indexed-object */ + "./node_modules/core-js/internals/indexed-object.js" + ); + var requireObjectCoercible = __webpack_require__( + /*! ../internals/require-object-coercible */ + "./node_modules/core-js/internals/require-object-coercible.js" + ); + module3.exports = function(it) { + return IndexedObject(requireObjectCoercible(it)); + }; + } + ), + /***/ + "./node_modules/core-js/internals/to-integer.js": ( + /*!******************************************************!*\ + !*** ./node_modules/core-js/internals/to-integer.js ***! + \******************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3) { + var ceil = Math.ceil; + var floor = Math.floor; + module3.exports = function(argument) { + return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument); + }; + } + ), + /***/ + "./node_modules/core-js/internals/to-length.js": ( + /*!*****************************************************!*\ + !*** ./node_modules/core-js/internals/to-length.js ***! + \*****************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var toInteger = __webpack_require__( + /*! ../internals/to-integer */ + "./node_modules/core-js/internals/to-integer.js" + ); + var min = Math.min; + module3.exports = function(argument) { + return argument > 0 ? min(toInteger(argument), 9007199254740991) : 0; + }; + } + ), + /***/ + "./node_modules/core-js/internals/to-object.js": ( + /*!*****************************************************!*\ + !*** ./node_modules/core-js/internals/to-object.js ***! + \*****************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var requireObjectCoercible = __webpack_require__( + /*! ../internals/require-object-coercible */ + "./node_modules/core-js/internals/require-object-coercible.js" + ); + module3.exports = function(argument) { + return Object(requireObjectCoercible(argument)); + }; + } + ), + /***/ + "./node_modules/core-js/internals/to-primitive.js": ( + /*!********************************************************!*\ + !*** ./node_modules/core-js/internals/to-primitive.js ***! + \********************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var isObject = __webpack_require__( + /*! ../internals/is-object */ + "./node_modules/core-js/internals/is-object.js" + ); + module3.exports = function(it, S) { + if (!isObject(it)) + return it; + var fn, val; + if (S && typeof (fn = it.toString) == "function" && !isObject(val = fn.call(it))) + return val; + if (typeof (fn = it.valueOf) == "function" && !isObject(val = fn.call(it))) + return val; + if (!S && typeof (fn = it.toString) == "function" && !isObject(val = fn.call(it))) + return val; + throw TypeError("Can't convert object to primitive value"); + }; + } + ), + /***/ + "./node_modules/core-js/internals/uid.js": ( + /*!***********************************************!*\ + !*** ./node_modules/core-js/internals/uid.js ***! + \***********************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3) { + var id = 0; + var postfix = Math.random(); + module3.exports = function(key2) { + return "Symbol(".concat(key2 === void 0 ? "" : key2, ")_", (++id + postfix).toString(36)); + }; + } + ), + /***/ + "./node_modules/core-js/internals/validate-set-prototype-of-arguments.js": ( + /*!*******************************************************************************!*\ + !*** ./node_modules/core-js/internals/validate-set-prototype-of-arguments.js ***! + \*******************************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var isObject = __webpack_require__( + /*! ../internals/is-object */ + "./node_modules/core-js/internals/is-object.js" + ); + var anObject = __webpack_require__( + /*! ../internals/an-object */ + "./node_modules/core-js/internals/an-object.js" + ); + module3.exports = function(O, proto) { + anObject(O); + if (!isObject(proto) && proto !== null) { + throw TypeError("Can't set " + String(proto) + " as a prototype"); + } + }; + } + ), + /***/ + "./node_modules/core-js/internals/well-known-symbol.js": ( + /*!*************************************************************!*\ + !*** ./node_modules/core-js/internals/well-known-symbol.js ***! + \*************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var global2 = __webpack_require__( + /*! ../internals/global */ + "./node_modules/core-js/internals/global.js" + ); + var shared = __webpack_require__( + /*! ../internals/shared */ + "./node_modules/core-js/internals/shared.js" + ); + var uid = __webpack_require__( + /*! ../internals/uid */ + "./node_modules/core-js/internals/uid.js" + ); + var NATIVE_SYMBOL = __webpack_require__( + /*! ../internals/native-symbol */ + "./node_modules/core-js/internals/native-symbol.js" + ); + var Symbol2 = global2.Symbol; + var store = shared("wks"); + module3.exports = function(name) { + return store[name] || (store[name] = NATIVE_SYMBOL && Symbol2[name] || (NATIVE_SYMBOL ? Symbol2 : uid)("Symbol." + name)); + }; + } + ), + /***/ + "./node_modules/core-js/modules/es.array.from.js": ( + /*!*******************************************************!*\ + !*** ./node_modules/core-js/modules/es.array.from.js ***! + \*******************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + var $ = __webpack_require__( + /*! ../internals/export */ + "./node_modules/core-js/internals/export.js" + ); + var from = __webpack_require__( + /*! ../internals/array-from */ + "./node_modules/core-js/internals/array-from.js" + ); + var checkCorrectnessOfIteration = __webpack_require__( + /*! ../internals/check-correctness-of-iteration */ + "./node_modules/core-js/internals/check-correctness-of-iteration.js" + ); + var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function(iterable) { + Array.from(iterable); + }); + $({ target: "Array", stat: true, forced: INCORRECT_ITERATION }, { + from + }); + } + ), + /***/ + "./node_modules/core-js/modules/es.string.iterator.js": ( + /*!************************************************************!*\ + !*** ./node_modules/core-js/modules/es.string.iterator.js ***! + \************************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + "use strict"; + var codePointAt = __webpack_require__( + /*! ../internals/string-at */ + "./node_modules/core-js/internals/string-at.js" + ); + var InternalStateModule = __webpack_require__( + /*! ../internals/internal-state */ + "./node_modules/core-js/internals/internal-state.js" + ); + var defineIterator = __webpack_require__( + /*! ../internals/define-iterator */ + "./node_modules/core-js/internals/define-iterator.js" + ); + var STRING_ITERATOR = "String Iterator"; + var setInternalState = InternalStateModule.set; + var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR); + defineIterator(String, "String", function(iterated) { + setInternalState(this, { + type: STRING_ITERATOR, + string: String(iterated), + index: 0 + }); + }, function next() { + var state = getInternalState(this); + var string = state.string; + var index2 = state.index; + var point; + if (index2 >= string.length) + return { value: void 0, done: true }; + point = codePointAt(string, index2, true); + state.index += point.length; + return { value: point, done: false }; + }); + } + ), + /***/ + "./node_modules/webpack/buildin/global.js": ( + /*!***********************************!*\ + !*** (webpack)/buildin/global.js ***! + \***********************************/ + /*! no static exports found */ + /***/ + function(module3, exports3) { + var g; + g = function() { + return this; + }(); + try { + g = g || Function("return this")() || (1, eval)("this"); + } catch (e) { + if (typeof window === "object") + g = window; + } + module3.exports = g; + } + ), + /***/ + "./src/default-attrs.json": ( + /*!********************************!*\ + !*** ./src/default-attrs.json ***! + \********************************/ + /*! exports provided: xmlns, width, height, viewBox, fill, stroke, stroke-width, stroke-linecap, stroke-linejoin, default */ + /***/ + function(module3) { + module3.exports = { "xmlns": "http://www.w3.org/2000/svg", "width": 24, "height": 24, "viewBox": "0 0 24 24", "fill": "none", "stroke": "currentColor", "stroke-width": 2, "stroke-linecap": "round", "stroke-linejoin": "round" }; + } + ), + /***/ + "./src/icon.js": ( + /*!*********************!*\ + !*** ./src/icon.js ***! + \*********************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + "use strict"; + Object.defineProperty(exports3, "__esModule", { + value: true + }); + var _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key2 in source) { + if (Object.prototype.hasOwnProperty.call(source, key2)) { + target[key2] = source[key2]; + } + } + } + return target; + }; + var _createClass = function() { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) + descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + return function(Constructor, protoProps, staticProps) { + if (protoProps) + defineProperties(Constructor.prototype, protoProps); + if (staticProps) + defineProperties(Constructor, staticProps); + return Constructor; + }; + }(); + var _dedupe = __webpack_require__( + /*! classnames/dedupe */ + "./node_modules/classnames/dedupe.js" + ); + var _dedupe2 = _interopRequireDefault(_dedupe); + var _defaultAttrs = __webpack_require__( + /*! ./default-attrs.json */ + "./src/default-attrs.json" + ); + var _defaultAttrs2 = _interopRequireDefault(_defaultAttrs); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function _classCallCheck(instance10, Constructor) { + if (!(instance10 instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + var Icon = function() { + function Icon2(name, contents) { + var tags = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : []; + _classCallCheck(this, Icon2); + this.name = name; + this.contents = contents; + this.tags = tags; + this.attrs = _extends({}, _defaultAttrs2.default, { class: "feather feather-" + name }); + } + _createClass(Icon2, [{ + key: "toSvg", + value: function toSvg() { + var attrs = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + var combinedAttrs = _extends({}, this.attrs, attrs, { class: (0, _dedupe2.default)(this.attrs.class, attrs.class) }); + return "" + this.contents + ""; + } + /** + * Return string representation of an `Icon`. + * + * Added for backward compatibility. If old code expects `feather.icons.` + * to be a string, `toString()` will get implicitly called. + * + * @returns {string} + */ + }, { + key: "toString", + value: function toString() { + return this.contents; + } + }]); + return Icon2; + }(); + function attrsToString(attrs) { + return Object.keys(attrs).map(function(key2) { + return key2 + '="' + attrs[key2] + '"'; + }).join(" "); + } + exports3.default = Icon; + } + ), + /***/ + "./src/icons.js": ( + /*!**********************!*\ + !*** ./src/icons.js ***! + \**********************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + "use strict"; + Object.defineProperty(exports3, "__esModule", { + value: true + }); + var _icon = __webpack_require__( + /*! ./icon */ + "./src/icon.js" + ); + var _icon2 = _interopRequireDefault(_icon); + var _icons = __webpack_require__( + /*! ../dist/icons.json */ + "./dist/icons.json" + ); + var _icons2 = _interopRequireDefault(_icons); + var _tags = __webpack_require__( + /*! ./tags.json */ + "./src/tags.json" + ); + var _tags2 = _interopRequireDefault(_tags); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + exports3.default = Object.keys(_icons2.default).map(function(key2) { + return new _icon2.default(key2, _icons2.default[key2], _tags2.default[key2]); + }).reduce(function(object, icon) { + object[icon.name] = icon; + return object; + }, {}); + } + ), + /***/ + "./src/index.js": ( + /*!**********************!*\ + !*** ./src/index.js ***! + \**********************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + "use strict"; + var _icons = __webpack_require__( + /*! ./icons */ + "./src/icons.js" + ); + var _icons2 = _interopRequireDefault(_icons); + var _toSvg = __webpack_require__( + /*! ./to-svg */ + "./src/to-svg.js" + ); + var _toSvg2 = _interopRequireDefault(_toSvg); + var _replace = __webpack_require__( + /*! ./replace */ + "./src/replace.js" + ); + var _replace2 = _interopRequireDefault(_replace); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + module3.exports = { icons: _icons2.default, toSvg: _toSvg2.default, replace: _replace2.default }; + } + ), + /***/ + "./src/replace.js": ( + /*!************************!*\ + !*** ./src/replace.js ***! + \************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + "use strict"; + Object.defineProperty(exports3, "__esModule", { + value: true + }); + var _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key2 in source) { + if (Object.prototype.hasOwnProperty.call(source, key2)) { + target[key2] = source[key2]; + } + } + } + return target; + }; + var _dedupe = __webpack_require__( + /*! classnames/dedupe */ + "./node_modules/classnames/dedupe.js" + ); + var _dedupe2 = _interopRequireDefault(_dedupe); + var _icons = __webpack_require__( + /*! ./icons */ + "./src/icons.js" + ); + var _icons2 = _interopRequireDefault(_icons); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function replace() { + var attrs = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + if (typeof document === "undefined") { + throw new Error("`feather.replace()` only works in a browser environment."); + } + var elementsToReplace = document.querySelectorAll("[data-feather]"); + Array.from(elementsToReplace).forEach(function(element2) { + return replaceElement(element2, attrs); + }); + } + function replaceElement(element2) { + var attrs = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + var elementAttrs = getAttrs(element2); + var name = elementAttrs["data-feather"]; + delete elementAttrs["data-feather"]; + var svgString = _icons2.default[name].toSvg(_extends({}, attrs, elementAttrs, { class: (0, _dedupe2.default)(attrs.class, elementAttrs.class) })); + var svgDocument = new DOMParser().parseFromString(svgString, "image/svg+xml"); + var svgElement = svgDocument.querySelector("svg"); + element2.parentNode.replaceChild(svgElement, element2); + } + function getAttrs(element2) { + return Array.from(element2.attributes).reduce(function(attrs, attr2) { + attrs[attr2.name] = attr2.value; + return attrs; + }, {}); + } + exports3.default = replace; + } + ), + /***/ + "./src/tags.json": ( + /*!***********************!*\ + !*** ./src/tags.json ***! + \***********************/ + /*! exports provided: activity, airplay, alert-circle, alert-octagon, alert-triangle, align-center, align-justify, align-left, align-right, anchor, archive, at-sign, award, aperture, bar-chart, bar-chart-2, battery, battery-charging, bell, bell-off, bluetooth, book-open, book, bookmark, box, briefcase, calendar, camera, cast, chevron-down, chevron-up, circle, clipboard, clock, cloud-drizzle, cloud-lightning, cloud-rain, cloud-snow, cloud, codepen, codesandbox, code, coffee, columns, command, compass, copy, corner-down-left, corner-down-right, corner-left-down, corner-left-up, corner-right-down, corner-right-up, corner-up-left, corner-up-right, cpu, credit-card, crop, crosshair, database, delete, disc, dollar-sign, droplet, edit, edit-2, edit-3, eye, eye-off, external-link, facebook, fast-forward, figma, file-minus, file-plus, file-text, film, filter, flag, folder-minus, folder-plus, folder, framer, frown, gift, git-branch, git-commit, git-merge, git-pull-request, github, gitlab, globe, hard-drive, hash, headphones, heart, help-circle, hexagon, home, image, inbox, instagram, key, layers, layout, life-bouy, link, link-2, linkedin, list, lock, log-in, log-out, mail, map-pin, map, maximize, maximize-2, meh, menu, message-circle, message-square, mic-off, mic, minimize, minimize-2, minus, monitor, moon, more-horizontal, more-vertical, mouse-pointer, move, music, navigation, navigation-2, octagon, package, paperclip, pause, pause-circle, pen-tool, percent, phone-call, phone-forwarded, phone-incoming, phone-missed, phone-off, phone-outgoing, phone, play, pie-chart, play-circle, plus, plus-circle, plus-square, pocket, power, printer, radio, refresh-cw, refresh-ccw, repeat, rewind, rotate-ccw, rotate-cw, rss, save, scissors, search, send, settings, share-2, shield, shield-off, shopping-bag, shopping-cart, shuffle, skip-back, skip-forward, slack, slash, sliders, smartphone, smile, speaker, star, stop-circle, sun, sunrise, sunset, tablet, tag, target, terminal, thermometer, thumbs-down, thumbs-up, toggle-left, toggle-right, tool, trash, trash-2, triangle, truck, tv, twitch, twitter, type, umbrella, unlock, user-check, user-minus, user-plus, user-x, user, users, video-off, video, voicemail, volume, volume-1, volume-2, volume-x, watch, wifi-off, wifi, wind, x-circle, x-octagon, x-square, x, youtube, zap-off, zap, zoom-in, zoom-out, default */ + /***/ + function(module3) { + module3.exports = { "activity": ["pulse", "health", "action", "motion"], "airplay": ["stream", "cast", "mirroring"], "alert-circle": ["warning", "alert", "danger"], "alert-octagon": ["warning", "alert", "danger"], "alert-triangle": ["warning", "alert", "danger"], "align-center": ["text alignment", "center"], "align-justify": ["text alignment", "justified"], "align-left": ["text alignment", "left"], "align-right": ["text alignment", "right"], "anchor": [], "archive": ["index", "box"], "at-sign": ["mention", "at", "email", "message"], "award": ["achievement", "badge"], "aperture": ["camera", "photo"], "bar-chart": ["statistics", "diagram", "graph"], "bar-chart-2": ["statistics", "diagram", "graph"], "battery": ["power", "electricity"], "battery-charging": ["power", "electricity"], "bell": ["alarm", "notification", "sound"], "bell-off": ["alarm", "notification", "silent"], "bluetooth": ["wireless"], "book-open": ["read", "library"], "book": ["read", "dictionary", "booklet", "magazine", "library"], "bookmark": ["read", "clip", "marker", "tag"], "box": ["cube"], "briefcase": ["work", "bag", "baggage", "folder"], "calendar": ["date"], "camera": ["photo"], "cast": ["chromecast", "airplay"], "chevron-down": ["expand"], "chevron-up": ["collapse"], "circle": ["off", "zero", "record"], "clipboard": ["copy"], "clock": ["time", "watch", "alarm"], "cloud-drizzle": ["weather", "shower"], "cloud-lightning": ["weather", "bolt"], "cloud-rain": ["weather"], "cloud-snow": ["weather", "blizzard"], "cloud": ["weather"], "codepen": ["logo"], "codesandbox": ["logo"], "code": ["source", "programming"], "coffee": ["drink", "cup", "mug", "tea", "cafe", "hot", "beverage"], "columns": ["layout"], "command": ["keyboard", "cmd", "terminal", "prompt"], "compass": ["navigation", "safari", "travel", "direction"], "copy": ["clone", "duplicate"], "corner-down-left": ["arrow", "return"], "corner-down-right": ["arrow"], "corner-left-down": ["arrow"], "corner-left-up": ["arrow"], "corner-right-down": ["arrow"], "corner-right-up": ["arrow"], "corner-up-left": ["arrow"], "corner-up-right": ["arrow"], "cpu": ["processor", "technology"], "credit-card": ["purchase", "payment", "cc"], "crop": ["photo", "image"], "crosshair": ["aim", "target"], "database": ["storage", "memory"], "delete": ["remove"], "disc": ["album", "cd", "dvd", "music"], "dollar-sign": ["currency", "money", "payment"], "droplet": ["water"], "edit": ["pencil", "change"], "edit-2": ["pencil", "change"], "edit-3": ["pencil", "change"], "eye": ["view", "watch"], "eye-off": ["view", "watch", "hide", "hidden"], "external-link": ["outbound"], "facebook": ["logo", "social"], "fast-forward": ["music"], "figma": ["logo", "design", "tool"], "file-minus": ["delete", "remove", "erase"], "file-plus": ["add", "create", "new"], "file-text": ["data", "txt", "pdf"], "film": ["movie", "video"], "filter": ["funnel", "hopper"], "flag": ["report"], "folder-minus": ["directory"], "folder-plus": ["directory"], "folder": ["directory"], "framer": ["logo", "design", "tool"], "frown": ["emoji", "face", "bad", "sad", "emotion"], "gift": ["present", "box", "birthday", "party"], "git-branch": ["code", "version control"], "git-commit": ["code", "version control"], "git-merge": ["code", "version control"], "git-pull-request": ["code", "version control"], "github": ["logo", "version control"], "gitlab": ["logo", "version control"], "globe": ["world", "browser", "language", "translate"], "hard-drive": ["computer", "server", "memory", "data"], "hash": ["hashtag", "number", "pound"], "headphones": ["music", "audio", "sound"], "heart": ["like", "love", "emotion"], "help-circle": ["question mark"], "hexagon": ["shape", "node.js", "logo"], "home": ["house", "living"], "image": ["picture"], "inbox": ["email"], "instagram": ["logo", "camera"], "key": ["password", "login", "authentication", "secure"], "layers": ["stack"], "layout": ["window", "webpage"], "life-bouy": ["help", "life ring", "support"], "link": ["chain", "url"], "link-2": ["chain", "url"], "linkedin": ["logo", "social media"], "list": ["options"], "lock": ["security", "password", "secure"], "log-in": ["sign in", "arrow", "enter"], "log-out": ["sign out", "arrow", "exit"], "mail": ["email", "message"], "map-pin": ["location", "navigation", "travel", "marker"], "map": ["location", "navigation", "travel"], "maximize": ["fullscreen"], "maximize-2": ["fullscreen", "arrows", "expand"], "meh": ["emoji", "face", "neutral", "emotion"], "menu": ["bars", "navigation", "hamburger"], "message-circle": ["comment", "chat"], "message-square": ["comment", "chat"], "mic-off": ["record", "sound", "mute"], "mic": ["record", "sound", "listen"], "minimize": ["exit fullscreen", "close"], "minimize-2": ["exit fullscreen", "arrows", "close"], "minus": ["subtract"], "monitor": ["tv", "screen", "display"], "moon": ["dark", "night"], "more-horizontal": ["ellipsis"], "more-vertical": ["ellipsis"], "mouse-pointer": ["arrow", "cursor"], "move": ["arrows"], "music": ["note"], "navigation": ["location", "travel"], "navigation-2": ["location", "travel"], "octagon": ["stop"], "package": ["box", "container"], "paperclip": ["attachment"], "pause": ["music", "stop"], "pause-circle": ["music", "audio", "stop"], "pen-tool": ["vector", "drawing"], "percent": ["discount"], "phone-call": ["ring"], "phone-forwarded": ["call"], "phone-incoming": ["call"], "phone-missed": ["call"], "phone-off": ["call", "mute"], "phone-outgoing": ["call"], "phone": ["call"], "play": ["music", "start"], "pie-chart": ["statistics", "diagram"], "play-circle": ["music", "start"], "plus": ["add", "new"], "plus-circle": ["add", "new"], "plus-square": ["add", "new"], "pocket": ["logo", "save"], "power": ["on", "off"], "printer": ["fax", "office", "device"], "radio": ["signal"], "refresh-cw": ["synchronise", "arrows"], "refresh-ccw": ["arrows"], "repeat": ["loop", "arrows"], "rewind": ["music"], "rotate-ccw": ["arrow"], "rotate-cw": ["arrow"], "rss": ["feed", "subscribe"], "save": ["floppy disk"], "scissors": ["cut"], "search": ["find", "magnifier", "magnifying glass"], "send": ["message", "mail", "email", "paper airplane", "paper aeroplane"], "settings": ["cog", "edit", "gear", "preferences"], "share-2": ["network", "connections"], "shield": ["security", "secure"], "shield-off": ["security", "insecure"], "shopping-bag": ["ecommerce", "cart", "purchase", "store"], "shopping-cart": ["ecommerce", "cart", "purchase", "store"], "shuffle": ["music"], "skip-back": ["music"], "skip-forward": ["music"], "slack": ["logo"], "slash": ["ban", "no"], "sliders": ["settings", "controls"], "smartphone": ["cellphone", "device"], "smile": ["emoji", "face", "happy", "good", "emotion"], "speaker": ["audio", "music"], "star": ["bookmark", "favorite", "like"], "stop-circle": ["media", "music"], "sun": ["brightness", "weather", "light"], "sunrise": ["weather", "time", "morning", "day"], "sunset": ["weather", "time", "evening", "night"], "tablet": ["device"], "tag": ["label"], "target": ["logo", "bullseye"], "terminal": ["code", "command line", "prompt"], "thermometer": ["temperature", "celsius", "fahrenheit", "weather"], "thumbs-down": ["dislike", "bad", "emotion"], "thumbs-up": ["like", "good", "emotion"], "toggle-left": ["on", "off", "switch"], "toggle-right": ["on", "off", "switch"], "tool": ["settings", "spanner"], "trash": ["garbage", "delete", "remove", "bin"], "trash-2": ["garbage", "delete", "remove", "bin"], "triangle": ["delta"], "truck": ["delivery", "van", "shipping", "transport", "lorry"], "tv": ["television", "stream"], "twitch": ["logo"], "twitter": ["logo", "social"], "type": ["text"], "umbrella": ["rain", "weather"], "unlock": ["security"], "user-check": ["followed", "subscribed"], "user-minus": ["delete", "remove", "unfollow", "unsubscribe"], "user-plus": ["new", "add", "create", "follow", "subscribe"], "user-x": ["delete", "remove", "unfollow", "unsubscribe", "unavailable"], "user": ["person", "account"], "users": ["group"], "video-off": ["camera", "movie", "film"], "video": ["camera", "movie", "film"], "voicemail": ["phone"], "volume": ["music", "sound", "mute"], "volume-1": ["music", "sound"], "volume-2": ["music", "sound"], "volume-x": ["music", "sound", "mute"], "watch": ["clock", "time"], "wifi-off": ["disabled"], "wifi": ["connection", "signal", "wireless"], "wind": ["weather", "air"], "x-circle": ["cancel", "close", "delete", "remove", "times", "clear"], "x-octagon": ["delete", "stop", "alert", "warning", "times", "clear"], "x-square": ["cancel", "close", "delete", "remove", "times", "clear"], "x": ["cancel", "close", "delete", "remove", "times", "clear"], "youtube": ["logo", "video", "play"], "zap-off": ["flash", "camera", "lightning"], "zap": ["flash", "camera", "lightning"], "zoom-in": ["magnifying glass"], "zoom-out": ["magnifying glass"] }; + } + ), + /***/ + "./src/to-svg.js": ( + /*!***********************!*\ + !*** ./src/to-svg.js ***! + \***********************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + "use strict"; + Object.defineProperty(exports3, "__esModule", { + value: true + }); + var _icons = __webpack_require__( + /*! ./icons */ + "./src/icons.js" + ); + var _icons2 = _interopRequireDefault(_icons); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function toSvg(name) { + var attrs = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + console.warn("feather.toSvg() is deprecated. Please use feather.icons[name].toSvg() instead."); + if (!name) { + throw new Error("The required `key` (icon name) parameter is missing."); + } + if (!_icons2.default[name]) { + throw new Error("No icon matching '" + name + "'. See the complete list of icons at https://feathericons.com"); + } + return _icons2.default[name].toSvg(attrs); + } + exports3.default = toSvg; + } + ), + /***/ + 0: ( + /*!**************************************************!*\ + !*** multi core-js/es/array/from ./src/index.js ***! + \**************************************************/ + /*! no static exports found */ + /***/ + function(module3, exports3, __webpack_require__) { + __webpack_require__( + /*! core-js/es/array/from */ + "./node_modules/core-js/es/array/from.js" + ); + module3.exports = __webpack_require__( + /*! /home/runner/work/feather/feather/src/index.js */ + "./src/index.js" + ); + } + ) + /******/ + }) + ); + }); + } +}); + +// src/main.ts +var main_exports = {}; +__export(main_exports, { + default: () => ObsidianGit +}); +module.exports = __toCommonJS(main_exports); +init_polyfill_buffer(); + +// node_modules/.pnpm/isomorphic-git@1.24.2/node_modules/isomorphic-git/index.js +init_polyfill_buffer(); +var import_async_lock = __toESM(require_async_lock(), 1); +var import_sha1 = __toESM(require_sha1(), 1); +var import_crc_32 = __toESM(require_crc32(), 1); +var import_pako = __toESM(require_pako(), 1); +var import_pify = __toESM(require_pify(), 1); +var import_ignore = __toESM(require_ignore(), 1); +var import_clean_git_ref = __toESM(require_lib2(), 1); +var import_diff3 = __toESM(require_diff3(), 1); +var BaseError = class _BaseError extends Error { + constructor(message) { + super(message); + this.caller = ""; + } + toJSON() { + return { + code: this.code, + data: this.data, + caller: this.caller, + message: this.message, + stack: this.stack + }; + } + fromJSON(json) { + const e = new _BaseError(json.message); + e.code = json.code; + e.data = json.data; + e.caller = json.caller; + e.stack = json.stack; + return e; + } + get isIsomorphicGitError() { + return true; + } +}; +var UnmergedPathsError = class _UnmergedPathsError extends BaseError { + /** + * @param {Array} filepaths + */ + constructor(filepaths) { + super( + `Modifying the index is not possible because you have unmerged files: ${filepaths.toString}. Fix them up in the work tree, and then use 'git add/rm as appropriate to mark resolution and make a commit.` + ); + this.code = this.name = _UnmergedPathsError.code; + this.data = { filepaths }; + } +}; +UnmergedPathsError.code = "UnmergedPathsError"; +var InternalError = class _InternalError extends BaseError { + /** + * @param {string} message + */ + constructor(message) { + super( + `An internal error caused this command to fail. Please file a bug report at https://github.com/isomorphic-git/isomorphic-git/issues with this error message: ${message}` + ); + this.code = this.name = _InternalError.code; + this.data = { message }; + } +}; +InternalError.code = "InternalError"; +var UnsafeFilepathError = class _UnsafeFilepathError extends BaseError { + /** + * @param {string} filepath + */ + constructor(filepath) { + super(`The filepath "${filepath}" contains unsafe character sequences`); + this.code = this.name = _UnsafeFilepathError.code; + this.data = { filepath }; + } +}; +UnsafeFilepathError.code = "UnsafeFilepathError"; +var BufferCursor = class { + constructor(buffer2) { + this.buffer = buffer2; + this._start = 0; + } + eof() { + return this._start >= this.buffer.length; + } + tell() { + return this._start; + } + seek(n) { + this._start = n; + } + slice(n) { + const r = this.buffer.slice(this._start, this._start + n); + this._start += n; + return r; + } + toString(enc, length) { + const r = this.buffer.toString(enc, this._start, this._start + length); + this._start += length; + return r; + } + write(value, length, enc) { + const r = this.buffer.write(value, this._start, length, enc); + this._start += length; + return r; + } + copy(source, start, end) { + const r = source.copy(this.buffer, this._start, start, end); + this._start += r; + return r; + } + readUInt8() { + const r = this.buffer.readUInt8(this._start); + this._start += 1; + return r; + } + writeUInt8(value) { + const r = this.buffer.writeUInt8(value, this._start); + this._start += 1; + return r; + } + readUInt16BE() { + const r = this.buffer.readUInt16BE(this._start); + this._start += 2; + return r; + } + writeUInt16BE(value) { + const r = this.buffer.writeUInt16BE(value, this._start); + this._start += 2; + return r; + } + readUInt32BE() { + const r = this.buffer.readUInt32BE(this._start); + this._start += 4; + return r; + } + writeUInt32BE(value) { + const r = this.buffer.writeUInt32BE(value, this._start); + this._start += 4; + return r; + } +}; +function compareStrings(a, b) { + return -(a < b) || +(a > b); +} +function comparePath(a, b) { + return compareStrings(a.path, b.path); +} +function normalizeMode(mode) { + let type = mode > 0 ? mode >> 12 : 0; + if (type !== 4 && type !== 8 && type !== 10 && type !== 14) { + type = 8; + } + let permissions = mode & 511; + if (permissions & 73) { + permissions = 493; + } else { + permissions = 420; + } + if (type !== 8) + permissions = 0; + return (type << 12) + permissions; +} +var MAX_UINT32 = 2 ** 32; +function SecondsNanoseconds(givenSeconds, givenNanoseconds, milliseconds, date) { + if (givenSeconds !== void 0 && givenNanoseconds !== void 0) { + return [givenSeconds, givenNanoseconds]; + } + if (milliseconds === void 0) { + milliseconds = date.valueOf(); + } + const seconds = Math.floor(milliseconds / 1e3); + const nanoseconds = (milliseconds - seconds * 1e3) * 1e6; + return [seconds, nanoseconds]; +} +function normalizeStats(e) { + const [ctimeSeconds, ctimeNanoseconds] = SecondsNanoseconds( + e.ctimeSeconds, + e.ctimeNanoseconds, + e.ctimeMs, + e.ctime + ); + const [mtimeSeconds, mtimeNanoseconds] = SecondsNanoseconds( + e.mtimeSeconds, + e.mtimeNanoseconds, + e.mtimeMs, + e.mtime + ); + return { + ctimeSeconds: ctimeSeconds % MAX_UINT32, + ctimeNanoseconds: ctimeNanoseconds % MAX_UINT32, + mtimeSeconds: mtimeSeconds % MAX_UINT32, + mtimeNanoseconds: mtimeNanoseconds % MAX_UINT32, + dev: e.dev % MAX_UINT32, + ino: e.ino % MAX_UINT32, + mode: normalizeMode(e.mode % MAX_UINT32), + uid: e.uid % MAX_UINT32, + gid: e.gid % MAX_UINT32, + // size of -1 happens over a BrowserFS HTTP Backend that doesn't serve Content-Length headers + // (like the Karma webserver) because BrowserFS HTTP Backend uses HTTP HEAD requests to do fs.stat + size: e.size > -1 ? e.size % MAX_UINT32 : 0 + }; +} +function toHex(buffer2) { + let hex = ""; + for (const byte of new Uint8Array(buffer2)) { + if (byte < 16) + hex += "0"; + hex += byte.toString(16); + } + return hex; +} +var supportsSubtleSHA1 = null; +async function shasum(buffer2) { + if (supportsSubtleSHA1 === null) { + supportsSubtleSHA1 = await testSubtleSHA1(); + } + return supportsSubtleSHA1 ? subtleSHA1(buffer2) : shasumSync(buffer2); +} +function shasumSync(buffer2) { + return new import_sha1.default().update(buffer2).digest("hex"); +} +async function subtleSHA1(buffer2) { + const hash2 = await crypto.subtle.digest("SHA-1", buffer2); + return toHex(hash2); +} +async function testSubtleSHA1() { + try { + const hash2 = await subtleSHA1(new Uint8Array([])); + if (hash2 === "da39a3ee5e6b4b0d3255bfef95601890afd80709") + return true; + } catch (_) { + } + return false; +} +function parseCacheEntryFlags(bits) { + return { + assumeValid: Boolean(bits & 32768), + extended: Boolean(bits & 16384), + stage: (bits & 12288) >> 12, + nameLength: bits & 4095 + }; +} +function renderCacheEntryFlags(entry) { + const flags = entry.flags; + flags.extended = false; + flags.nameLength = Math.min(Buffer.from(entry.path).length, 4095); + return (flags.assumeValid ? 32768 : 0) + (flags.extended ? 16384 : 0) + ((flags.stage & 3) << 12) + (flags.nameLength & 4095); +} +var GitIndex = class _GitIndex { + /*:: + _entries: Map + _dirty: boolean // Used to determine if index needs to be saved to filesystem + */ + constructor(entries, unmergedPaths) { + this._dirty = false; + this._unmergedPaths = unmergedPaths || /* @__PURE__ */ new Set(); + this._entries = entries || /* @__PURE__ */ new Map(); + } + _addEntry(entry) { + if (entry.flags.stage === 0) { + entry.stages = [entry]; + this._entries.set(entry.path, entry); + this._unmergedPaths.delete(entry.path); + } else { + let existingEntry = this._entries.get(entry.path); + if (!existingEntry) { + this._entries.set(entry.path, entry); + existingEntry = entry; + } + existingEntry.stages[entry.flags.stage] = entry; + this._unmergedPaths.add(entry.path); + } + } + static async from(buffer2) { + if (Buffer.isBuffer(buffer2)) { + return _GitIndex.fromBuffer(buffer2); + } else if (buffer2 === null) { + return new _GitIndex(null); + } else { + throw new InternalError("invalid type passed to GitIndex.from"); + } + } + static async fromBuffer(buffer2) { + if (buffer2.length === 0) { + throw new InternalError("Index file is empty (.git/index)"); + } + const index2 = new _GitIndex(); + const reader = new BufferCursor(buffer2); + const magic = reader.toString("utf8", 4); + if (magic !== "DIRC") { + throw new InternalError(`Invalid dircache magic file number: ${magic}`); + } + const shaComputed = await shasum(buffer2.slice(0, -20)); + const shaClaimed = buffer2.slice(-20).toString("hex"); + if (shaClaimed !== shaComputed) { + throw new InternalError( + `Invalid checksum in GitIndex buffer: expected ${shaClaimed} but saw ${shaComputed}` + ); + } + const version2 = reader.readUInt32BE(); + if (version2 !== 2) { + throw new InternalError(`Unsupported dircache version: ${version2}`); + } + const numEntries = reader.readUInt32BE(); + let i = 0; + while (!reader.eof() && i < numEntries) { + const entry = {}; + entry.ctimeSeconds = reader.readUInt32BE(); + entry.ctimeNanoseconds = reader.readUInt32BE(); + entry.mtimeSeconds = reader.readUInt32BE(); + entry.mtimeNanoseconds = reader.readUInt32BE(); + entry.dev = reader.readUInt32BE(); + entry.ino = reader.readUInt32BE(); + entry.mode = reader.readUInt32BE(); + entry.uid = reader.readUInt32BE(); + entry.gid = reader.readUInt32BE(); + entry.size = reader.readUInt32BE(); + entry.oid = reader.slice(20).toString("hex"); + const flags = reader.readUInt16BE(); + entry.flags = parseCacheEntryFlags(flags); + const pathlength = buffer2.indexOf(0, reader.tell() + 1) - reader.tell(); + if (pathlength < 1) { + throw new InternalError(`Got a path length of: ${pathlength}`); + } + entry.path = reader.toString("utf8", pathlength); + if (entry.path.includes("..\\") || entry.path.includes("../")) { + throw new UnsafeFilepathError(entry.path); + } + let padding = 8 - (reader.tell() - 12) % 8; + if (padding === 0) + padding = 8; + while (padding--) { + const tmp = reader.readUInt8(); + if (tmp !== 0) { + throw new InternalError( + `Expected 1-8 null characters but got '${tmp}' after ${entry.path}` + ); + } else if (reader.eof()) { + throw new InternalError("Unexpected end of file"); + } + } + entry.stages = []; + index2._addEntry(entry); + i++; + } + return index2; + } + get unmergedPaths() { + return [...this._unmergedPaths]; + } + get entries() { + return [...this._entries.values()].sort(comparePath); + } + get entriesMap() { + return this._entries; + } + get entriesFlat() { + return [...this.entries].flatMap((entry) => { + return entry.stages.length > 1 ? entry.stages.filter((x) => x) : entry; + }); + } + *[Symbol.iterator]() { + for (const entry of this.entries) { + yield entry; + } + } + insert({ filepath, stats, oid, stage = 0 }) { + if (!stats) { + stats = { + ctimeSeconds: 0, + ctimeNanoseconds: 0, + mtimeSeconds: 0, + mtimeNanoseconds: 0, + dev: 0, + ino: 0, + mode: 0, + uid: 0, + gid: 0, + size: 0 + }; + } + stats = normalizeStats(stats); + const bfilepath = Buffer.from(filepath); + const entry = { + ctimeSeconds: stats.ctimeSeconds, + ctimeNanoseconds: stats.ctimeNanoseconds, + mtimeSeconds: stats.mtimeSeconds, + mtimeNanoseconds: stats.mtimeNanoseconds, + dev: stats.dev, + ino: stats.ino, + // We provide a fallback value for `mode` here because not all fs + // implementations assign it, but we use it in GitTree. + // '100644' is for a "regular non-executable file" + mode: stats.mode || 33188, + uid: stats.uid, + gid: stats.gid, + size: stats.size, + path: filepath, + oid, + flags: { + assumeValid: false, + extended: false, + stage, + nameLength: bfilepath.length < 4095 ? bfilepath.length : 4095 + }, + stages: [] + }; + this._addEntry(entry); + this._dirty = true; + } + delete({ filepath }) { + if (this._entries.has(filepath)) { + this._entries.delete(filepath); + } else { + for (const key2 of this._entries.keys()) { + if (key2.startsWith(filepath + "/")) { + this._entries.delete(key2); + } + } + } + if (this._unmergedPaths.has(filepath)) { + this._unmergedPaths.delete(filepath); + } + this._dirty = true; + } + clear() { + this._entries.clear(); + this._dirty = true; + } + has({ filepath }) { + return this._entries.has(filepath); + } + render() { + return this.entries.map((entry) => `${entry.mode.toString(8)} ${entry.oid} ${entry.path}`).join("\n"); + } + static async _entryToBuffer(entry) { + const bpath = Buffer.from(entry.path); + const length = Math.ceil((62 + bpath.length + 1) / 8) * 8; + const written = Buffer.alloc(length); + const writer = new BufferCursor(written); + const stat = normalizeStats(entry); + writer.writeUInt32BE(stat.ctimeSeconds); + writer.writeUInt32BE(stat.ctimeNanoseconds); + writer.writeUInt32BE(stat.mtimeSeconds); + writer.writeUInt32BE(stat.mtimeNanoseconds); + writer.writeUInt32BE(stat.dev); + writer.writeUInt32BE(stat.ino); + writer.writeUInt32BE(stat.mode); + writer.writeUInt32BE(stat.uid); + writer.writeUInt32BE(stat.gid); + writer.writeUInt32BE(stat.size); + writer.write(entry.oid, 20, "hex"); + writer.writeUInt16BE(renderCacheEntryFlags(entry)); + writer.write(entry.path, bpath.length, "utf8"); + return written; + } + async toObject() { + const header = Buffer.alloc(12); + const writer = new BufferCursor(header); + writer.write("DIRC", 4, "utf8"); + writer.writeUInt32BE(2); + writer.writeUInt32BE(this.entriesFlat.length); + let entryBuffers = []; + for (const entry of this.entries) { + entryBuffers.push(_GitIndex._entryToBuffer(entry)); + if (entry.stages.length > 1) { + for (const stage of entry.stages) { + if (stage && stage !== entry) { + entryBuffers.push(_GitIndex._entryToBuffer(stage)); + } + } + } + } + entryBuffers = await Promise.all(entryBuffers); + const body = Buffer.concat(entryBuffers); + const main = Buffer.concat([header, body]); + const sum = await shasum(main); + return Buffer.concat([main, Buffer.from(sum, "hex")]); + } +}; +function compareStats(entry, stats) { + const e = normalizeStats(entry); + const s = normalizeStats(stats); + const staleness = e.mode !== s.mode || e.mtimeSeconds !== s.mtimeSeconds || e.ctimeSeconds !== s.ctimeSeconds || e.uid !== s.uid || e.gid !== s.gid || e.ino !== s.ino || e.size !== s.size; + return staleness; +} +var lock = null; +var IndexCache = Symbol("IndexCache"); +function createCache() { + return { + map: /* @__PURE__ */ new Map(), + stats: /* @__PURE__ */ new Map() + }; +} +async function updateCachedIndexFile(fs, filepath, cache) { + const stat = await fs.lstat(filepath); + const rawIndexFile = await fs.read(filepath); + const index2 = await GitIndex.from(rawIndexFile); + cache.map.set(filepath, index2); + cache.stats.set(filepath, stat); +} +async function isIndexStale(fs, filepath, cache) { + const savedStats = cache.stats.get(filepath); + if (savedStats === void 0) + return true; + const currStats = await fs.lstat(filepath); + if (savedStats === null) + return false; + if (currStats === null) + return false; + return compareStats(savedStats, currStats); +} +var GitIndexManager = class { + /** + * + * @param {object} opts + * @param {import('../models/FileSystem.js').FileSystem} opts.fs + * @param {string} opts.gitdir + * @param {object} opts.cache + * @param {bool} opts.allowUnmerged + * @param {function(GitIndex): any} closure + */ + static async acquire({ fs, gitdir, cache, allowUnmerged = true }, closure) { + if (!cache[IndexCache]) + cache[IndexCache] = createCache(); + const filepath = `${gitdir}/index`; + if (lock === null) + lock = new import_async_lock.default({ maxPending: Infinity }); + let result; + let unmergedPaths = []; + await lock.acquire(filepath, async () => { + if (await isIndexStale(fs, filepath, cache[IndexCache])) { + await updateCachedIndexFile(fs, filepath, cache[IndexCache]); + } + const index2 = cache[IndexCache].map.get(filepath); + unmergedPaths = index2.unmergedPaths; + if (unmergedPaths.length && !allowUnmerged) + throw new UnmergedPathsError(unmergedPaths); + result = await closure(index2); + if (index2._dirty) { + const buffer2 = await index2.toObject(); + await fs.write(filepath, buffer2); + cache[IndexCache].stats.set(filepath, await fs.lstat(filepath)); + index2._dirty = false; + } + }); + return result; + } +}; +function basename(path2) { + const last2 = Math.max(path2.lastIndexOf("/"), path2.lastIndexOf("\\")); + if (last2 > -1) { + path2 = path2.slice(last2 + 1); + } + return path2; +} +function dirname(path2) { + const last2 = Math.max(path2.lastIndexOf("/"), path2.lastIndexOf("\\")); + if (last2 === -1) + return "."; + if (last2 === 0) + return "/"; + return path2.slice(0, last2); +} +function flatFileListToDirectoryStructure(files) { + const inodes = /* @__PURE__ */ new Map(); + const mkdir = function(name) { + if (!inodes.has(name)) { + const dir = { + type: "tree", + fullpath: name, + basename: basename(name), + metadata: {}, + children: [] + }; + inodes.set(name, dir); + dir.parent = mkdir(dirname(name)); + if (dir.parent && dir.parent !== dir) + dir.parent.children.push(dir); + } + return inodes.get(name); + }; + const mkfile = function(name, metadata) { + if (!inodes.has(name)) { + const file = { + type: "blob", + fullpath: name, + basename: basename(name), + metadata, + // This recursively generates any missing parent folders. + parent: mkdir(dirname(name)), + children: [] + }; + if (file.parent) + file.parent.children.push(file); + inodes.set(name, file); + } + return inodes.get(name); + }; + mkdir("."); + for (const file of files) { + mkfile(file.path, file); + } + return inodes; +} +function mode2type(mode) { + switch (mode) { + case 16384: + return "tree"; + case 33188: + return "blob"; + case 33261: + return "blob"; + case 40960: + return "blob"; + case 57344: + return "commit"; + } + throw new InternalError(`Unexpected GitTree entry mode: ${mode.toString(8)}`); +} +var GitWalkerIndex = class { + constructor({ fs, gitdir, cache }) { + this.treePromise = GitIndexManager.acquire( + { fs, gitdir, cache }, + async function(index2) { + return flatFileListToDirectoryStructure(index2.entries); + } + ); + const walker = this; + this.ConstructEntry = class StageEntry { + constructor(fullpath) { + this._fullpath = fullpath; + this._type = false; + this._mode = false; + this._stat = false; + this._oid = false; + } + async type() { + return walker.type(this); + } + async mode() { + return walker.mode(this); + } + async stat() { + return walker.stat(this); + } + async content() { + return walker.content(this); + } + async oid() { + return walker.oid(this); + } + }; + } + async readdir(entry) { + const filepath = entry._fullpath; + const tree = await this.treePromise; + const inode = tree.get(filepath); + if (!inode) + return null; + if (inode.type === "blob") + return null; + if (inode.type !== "tree") { + throw new Error(`ENOTDIR: not a directory, scandir '${filepath}'`); + } + const names = inode.children.map((inode2) => inode2.fullpath); + names.sort(compareStrings); + return names; + } + async type(entry) { + if (entry._type === false) { + await entry.stat(); + } + return entry._type; + } + async mode(entry) { + if (entry._mode === false) { + await entry.stat(); + } + return entry._mode; + } + async stat(entry) { + if (entry._stat === false) { + const tree = await this.treePromise; + const inode = tree.get(entry._fullpath); + if (!inode) { + throw new Error( + `ENOENT: no such file or directory, lstat '${entry._fullpath}'` + ); + } + const stats = inode.type === "tree" ? {} : normalizeStats(inode.metadata); + entry._type = inode.type === "tree" ? "tree" : mode2type(stats.mode); + entry._mode = stats.mode; + if (inode.type === "tree") { + entry._stat = void 0; + } else { + entry._stat = stats; + } + } + return entry._stat; + } + async content(_entry) { + } + async oid(entry) { + if (entry._oid === false) { + const tree = await this.treePromise; + const inode = tree.get(entry._fullpath); + entry._oid = inode.metadata.oid; + } + return entry._oid; + } +}; +var GitWalkSymbol = Symbol("GitWalkSymbol"); +function STAGE() { + const o = /* @__PURE__ */ Object.create(null); + Object.defineProperty(o, GitWalkSymbol, { + value: function({ fs, gitdir, cache }) { + return new GitWalkerIndex({ fs, gitdir, cache }); + } + }); + Object.freeze(o); + return o; +} +var NotFoundError = class _NotFoundError extends BaseError { + /** + * @param {string} what + */ + constructor(what) { + super(`Could not find ${what}.`); + this.code = this.name = _NotFoundError.code; + this.data = { what }; + } +}; +NotFoundError.code = "NotFoundError"; +var ObjectTypeError = class _ObjectTypeError extends BaseError { + /** + * @param {string} oid + * @param {'blob'|'commit'|'tag'|'tree'} actual + * @param {'blob'|'commit'|'tag'|'tree'} expected + * @param {string} [filepath] + */ + constructor(oid, actual, expected, filepath) { + super( + `Object ${oid} ${filepath ? `at ${filepath}` : ""}was anticipated to be a ${expected} but it is a ${actual}.` + ); + this.code = this.name = _ObjectTypeError.code; + this.data = { oid, actual, expected, filepath }; + } +}; +ObjectTypeError.code = "ObjectTypeError"; +var InvalidOidError = class _InvalidOidError extends BaseError { + /** + * @param {string} value + */ + constructor(value) { + super(`Expected a 40-char hex object id but saw "${value}".`); + this.code = this.name = _InvalidOidError.code; + this.data = { value }; + } +}; +InvalidOidError.code = "InvalidOidError"; +var NoRefspecError = class _NoRefspecError extends BaseError { + /** + * @param {string} remote + */ + constructor(remote) { + super(`Could not find a fetch refspec for remote "${remote}". Make sure the config file has an entry like the following: +[remote "${remote}"] + fetch = +refs/heads/*:refs/remotes/origin/* +`); + this.code = this.name = _NoRefspecError.code; + this.data = { remote }; + } +}; +NoRefspecError.code = "NoRefspecError"; +var GitPackedRefs = class _GitPackedRefs { + constructor(text2) { + this.refs = /* @__PURE__ */ new Map(); + this.parsedConfig = []; + if (text2) { + let key2 = null; + this.parsedConfig = text2.trim().split("\n").map((line) => { + if (/^\s*#/.test(line)) { + return { line, comment: true }; + } + const i = line.indexOf(" "); + if (line.startsWith("^")) { + const value = line.slice(1); + this.refs.set(key2 + "^{}", value); + return { line, ref: key2, peeled: value }; + } else { + const value = line.slice(0, i); + key2 = line.slice(i + 1); + this.refs.set(key2, value); + return { line, ref: key2, oid: value }; + } + }); + } + return this; + } + static from(text2) { + return new _GitPackedRefs(text2); + } + delete(ref) { + this.parsedConfig = this.parsedConfig.filter((entry) => entry.ref !== ref); + this.refs.delete(ref); + } + toString() { + return this.parsedConfig.map(({ line }) => line).join("\n") + "\n"; + } +}; +var GitRefSpec = class _GitRefSpec { + constructor({ remotePath, localPath, force, matchPrefix }) { + Object.assign(this, { + remotePath, + localPath, + force, + matchPrefix + }); + } + static from(refspec) { + const [ + forceMatch, + remotePath, + remoteGlobMatch, + localPath, + localGlobMatch + ] = refspec.match(/^(\+?)(.*?)(\*?):(.*?)(\*?)$/).slice(1); + const force = forceMatch === "+"; + const remoteIsGlob = remoteGlobMatch === "*"; + const localIsGlob = localGlobMatch === "*"; + if (remoteIsGlob !== localIsGlob) { + throw new InternalError("Invalid refspec"); + } + return new _GitRefSpec({ + remotePath, + localPath, + force, + matchPrefix: remoteIsGlob + }); + } + translate(remoteBranch) { + if (this.matchPrefix) { + if (remoteBranch.startsWith(this.remotePath)) { + return this.localPath + remoteBranch.replace(this.remotePath, ""); + } + } else { + if (remoteBranch === this.remotePath) + return this.localPath; + } + return null; + } + reverseTranslate(localBranch) { + if (this.matchPrefix) { + if (localBranch.startsWith(this.localPath)) { + return this.remotePath + localBranch.replace(this.localPath, ""); + } + } else { + if (localBranch === this.localPath) + return this.remotePath; + } + return null; + } +}; +var GitRefSpecSet = class _GitRefSpecSet { + constructor(rules = []) { + this.rules = rules; + } + static from(refspecs) { + const rules = []; + for (const refspec of refspecs) { + rules.push(GitRefSpec.from(refspec)); + } + return new _GitRefSpecSet(rules); + } + add(refspec) { + const rule = GitRefSpec.from(refspec); + this.rules.push(rule); + } + translate(remoteRefs) { + const result = []; + for (const rule of this.rules) { + for (const remoteRef of remoteRefs) { + const localRef = rule.translate(remoteRef); + if (localRef) { + result.push([remoteRef, localRef]); + } + } + } + return result; + } + translateOne(remoteRef) { + let result = null; + for (const rule of this.rules) { + const localRef = rule.translate(remoteRef); + if (localRef) { + result = localRef; + } + } + return result; + } + localNamespaces() { + return this.rules.filter((rule) => rule.matchPrefix).map((rule) => rule.localPath.replace(/\/$/, "")); + } +}; +function compareRefNames(a, b) { + const _a2 = a.replace(/\^\{\}$/, ""); + const _b = b.replace(/\^\{\}$/, ""); + const tmp = -(_a2 < _b) || +(_a2 > _b); + if (tmp === 0) { + return a.endsWith("^{}") ? 1 : -1; + } + return tmp; +} +function normalizePath(path2) { + return path2.replace(/\/\.\//g, "/").replace(/\/{2,}/g, "/").replace(/^\/\.$/, "/").replace(/^\.\/$/, ".").replace(/^\.\//, "").replace(/\/\.$/, "").replace(/(.+)\/$/, "$1").replace(/^$/, "."); +} +function join(...parts) { + return normalizePath(parts.map(normalizePath).join("/")); +} +var num = (val) => { + val = val.toLowerCase(); + let n = parseInt(val); + if (val.endsWith("k")) + n *= 1024; + if (val.endsWith("m")) + n *= 1024 * 1024; + if (val.endsWith("g")) + n *= 1024 * 1024 * 1024; + return n; +}; +var bool = (val) => { + val = val.trim().toLowerCase(); + if (val === "true" || val === "yes" || val === "on") + return true; + if (val === "false" || val === "no" || val === "off") + return false; + throw Error( + `Expected 'true', 'false', 'yes', 'no', 'on', or 'off', but got ${val}` + ); +}; +var schema = { + core: { + filemode: bool, + bare: bool, + logallrefupdates: bool, + symlinks: bool, + ignorecase: bool, + bigFileThreshold: num + } +}; +var SECTION_LINE_REGEX = /^\[([A-Za-z0-9-.]+)(?: "(.*)")?\]$/; +var SECTION_REGEX = /^[A-Za-z0-9-.]+$/; +var VARIABLE_LINE_REGEX = /^([A-Za-z][A-Za-z-]*)(?: *= *(.*))?$/; +var VARIABLE_NAME_REGEX = /^[A-Za-z][A-Za-z-]*$/; +var VARIABLE_VALUE_COMMENT_REGEX = /^(.*?)( *[#;].*)$/; +var extractSectionLine = (line) => { + const matches = SECTION_LINE_REGEX.exec(line); + if (matches != null) { + const [section, subsection] = matches.slice(1); + return [section, subsection]; + } + return null; +}; +var extractVariableLine = (line) => { + const matches = VARIABLE_LINE_REGEX.exec(line); + if (matches != null) { + const [name, rawValue = "true"] = matches.slice(1); + const valueWithoutComments = removeComments(rawValue); + const valueWithoutQuotes = removeQuotes(valueWithoutComments); + return [name, valueWithoutQuotes]; + } + return null; +}; +var removeComments = (rawValue) => { + const commentMatches = VARIABLE_VALUE_COMMENT_REGEX.exec(rawValue); + if (commentMatches == null) { + return rawValue; + } + const [valueWithoutComment, comment] = commentMatches.slice(1); + if (hasOddNumberOfQuotes(valueWithoutComment) && hasOddNumberOfQuotes(comment)) { + return `${valueWithoutComment}${comment}`; + } + return valueWithoutComment; +}; +var hasOddNumberOfQuotes = (text2) => { + const numberOfQuotes = (text2.match(/(?:^|[^\\])"/g) || []).length; + return numberOfQuotes % 2 !== 0; +}; +var removeQuotes = (text2) => { + return text2.split("").reduce((newText, c, idx, text3) => { + const isQuote = c === '"' && text3[idx - 1] !== "\\"; + const isEscapeForQuote = c === "\\" && text3[idx + 1] === '"'; + if (isQuote || isEscapeForQuote) { + return newText; + } + return newText + c; + }, ""); +}; +var lower = (text2) => { + return text2 != null ? text2.toLowerCase() : null; +}; +var getPath = (section, subsection, name) => { + return [lower(section), subsection, lower(name)].filter((a) => a != null).join("."); +}; +var normalizePath$1 = (path2) => { + const pathSegments = path2.split("."); + const section = pathSegments.shift(); + const name = pathSegments.pop(); + const subsection = pathSegments.length ? pathSegments.join(".") : void 0; + return { + section, + subsection, + name, + path: getPath(section, subsection, name), + sectionPath: getPath(section, subsection, null) + }; +}; +var findLastIndex = (array, callback) => { + return array.reduce((lastIndex, item, index2) => { + return callback(item) ? index2 : lastIndex; + }, -1); +}; +var GitConfig = class _GitConfig { + constructor(text2) { + let section = null; + let subsection = null; + this.parsedConfig = text2.split("\n").map((line) => { + let name = null; + let value = null; + const trimmedLine = line.trim(); + const extractedSection = extractSectionLine(trimmedLine); + const isSection = extractedSection != null; + if (isSection) { + ; + [section, subsection] = extractedSection; + } else { + const extractedVariable = extractVariableLine(trimmedLine); + const isVariable = extractedVariable != null; + if (isVariable) { + ; + [name, value] = extractedVariable; + } + } + const path2 = getPath(section, subsection, name); + return { line, isSection, section, subsection, name, value, path: path2 }; + }); + } + static from(text2) { + return new _GitConfig(text2); + } + async get(path2, getall = false) { + const normalizedPath = normalizePath$1(path2).path; + const allValues = this.parsedConfig.filter((config) => config.path === normalizedPath).map(({ section, name, value }) => { + const fn = schema[section] && schema[section][name]; + return fn ? fn(value) : value; + }); + return getall ? allValues : allValues.pop(); + } + async getall(path2) { + return this.get(path2, true); + } + async getSubsections(section) { + return this.parsedConfig.filter((config) => config.section === section && config.isSection).map((config) => config.subsection); + } + async deleteSection(section, subsection) { + this.parsedConfig = this.parsedConfig.filter( + (config) => !(config.section === section && config.subsection === subsection) + ); + } + async append(path2, value) { + return this.set(path2, value, true); + } + async set(path2, value, append3 = false) { + const { + section, + subsection, + name, + path: normalizedPath, + sectionPath + } = normalizePath$1(path2); + const configIndex = findLastIndex( + this.parsedConfig, + (config) => config.path === normalizedPath + ); + if (value == null) { + if (configIndex !== -1) { + this.parsedConfig.splice(configIndex, 1); + } + } else { + if (configIndex !== -1) { + const config = this.parsedConfig[configIndex]; + const modifiedConfig = Object.assign({}, config, { + name, + value, + modified: true + }); + if (append3) { + this.parsedConfig.splice(configIndex + 1, 0, modifiedConfig); + } else { + this.parsedConfig[configIndex] = modifiedConfig; + } + } else { + const sectionIndex = this.parsedConfig.findIndex( + (config) => config.path === sectionPath + ); + const newConfig = { + section, + subsection, + name, + value, + modified: true, + path: normalizedPath + }; + if (SECTION_REGEX.test(section) && VARIABLE_NAME_REGEX.test(name)) { + if (sectionIndex >= 0) { + this.parsedConfig.splice(sectionIndex + 1, 0, newConfig); + } else { + const newSection = { + section, + subsection, + modified: true, + path: sectionPath + }; + this.parsedConfig.push(newSection, newConfig); + } + } + } + } + } + toString() { + return this.parsedConfig.map(({ line, section, subsection, name, value, modified: modified2 = false }) => { + if (!modified2) { + return line; + } + if (name != null && value != null) { + if (typeof value === "string" && /[#;]/.test(value)) { + return ` ${name} = "${value}"`; + } + return ` ${name} = ${value}`; + } + if (subsection != null) { + return `[${section} "${subsection}"]`; + } + return `[${section}]`; + }).join("\n"); + } +}; +var GitConfigManager = class { + static async get({ fs, gitdir }) { + const text2 = await fs.read(`${gitdir}/config`, { encoding: "utf8" }); + return GitConfig.from(text2); + } + static async save({ fs, gitdir, config }) { + await fs.write(`${gitdir}/config`, config.toString(), { + encoding: "utf8" + }); + } +}; +var refpaths = (ref) => [ + `${ref}`, + `refs/${ref}`, + `refs/tags/${ref}`, + `refs/heads/${ref}`, + `refs/remotes/${ref}`, + `refs/remotes/${ref}/HEAD` +]; +var GIT_FILES = ["config", "description", "index", "shallow", "commondir"]; +var GitRefManager = class _GitRefManager { + static async updateRemoteRefs({ + fs, + gitdir, + remote, + refs, + symrefs, + tags, + refspecs = void 0, + prune = false, + pruneTags = false + }) { + for (const value of refs.values()) { + if (!value.match(/[0-9a-f]{40}/)) { + throw new InvalidOidError(value); + } + } + const config = await GitConfigManager.get({ fs, gitdir }); + if (!refspecs) { + refspecs = await config.getall(`remote.${remote}.fetch`); + if (refspecs.length === 0) { + throw new NoRefspecError(remote); + } + refspecs.unshift(`+HEAD:refs/remotes/${remote}/HEAD`); + } + const refspec = GitRefSpecSet.from(refspecs); + const actualRefsToWrite = /* @__PURE__ */ new Map(); + if (pruneTags) { + const tags2 = await _GitRefManager.listRefs({ + fs, + gitdir, + filepath: "refs/tags" + }); + await _GitRefManager.deleteRefs({ + fs, + gitdir, + refs: tags2.map((tag2) => `refs/tags/${tag2}`) + }); + } + if (tags) { + for (const serverRef of refs.keys()) { + if (serverRef.startsWith("refs/tags") && !serverRef.endsWith("^{}")) { + if (!await _GitRefManager.exists({ fs, gitdir, ref: serverRef })) { + const oid = refs.get(serverRef); + actualRefsToWrite.set(serverRef, oid); + } + } + } + } + const refTranslations = refspec.translate([...refs.keys()]); + for (const [serverRef, translatedRef] of refTranslations) { + const value = refs.get(serverRef); + actualRefsToWrite.set(translatedRef, value); + } + const symrefTranslations = refspec.translate([...symrefs.keys()]); + for (const [serverRef, translatedRef] of symrefTranslations) { + const value = symrefs.get(serverRef); + const symtarget = refspec.translateOne(value); + if (symtarget) { + actualRefsToWrite.set(translatedRef, `ref: ${symtarget}`); + } + } + const pruned = []; + if (prune) { + for (const filepath of refspec.localNamespaces()) { + const refs2 = (await _GitRefManager.listRefs({ + fs, + gitdir, + filepath + })).map((file) => `${filepath}/${file}`); + for (const ref of refs2) { + if (!actualRefsToWrite.has(ref)) { + pruned.push(ref); + } + } + } + if (pruned.length > 0) { + await _GitRefManager.deleteRefs({ fs, gitdir, refs: pruned }); + } + } + for (const [key2, value] of actualRefsToWrite) { + await fs.write(join(gitdir, key2), `${value.trim()} +`, "utf8"); + } + return { pruned }; + } + // TODO: make this less crude? + static async writeRef({ fs, gitdir, ref, value }) { + if (!value.match(/[0-9a-f]{40}/)) { + throw new InvalidOidError(value); + } + await fs.write(join(gitdir, ref), `${value.trim()} +`, "utf8"); + } + static async writeSymbolicRef({ fs, gitdir, ref, value }) { + await fs.write(join(gitdir, ref), `ref: ${value.trim()} +`, "utf8"); + } + static async deleteRef({ fs, gitdir, ref }) { + return _GitRefManager.deleteRefs({ fs, gitdir, refs: [ref] }); + } + static async deleteRefs({ fs, gitdir, refs }) { + await Promise.all(refs.map((ref) => fs.rm(join(gitdir, ref)))); + let text2 = await fs.read(`${gitdir}/packed-refs`, { encoding: "utf8" }); + const packed = GitPackedRefs.from(text2); + const beforeSize = packed.refs.size; + for (const ref of refs) { + if (packed.refs.has(ref)) { + packed.delete(ref); + } + } + if (packed.refs.size < beforeSize) { + text2 = packed.toString(); + await fs.write(`${gitdir}/packed-refs`, text2, { encoding: "utf8" }); + } + } + /** + * @param {object} args + * @param {import('../models/FileSystem.js').FileSystem} args.fs + * @param {string} args.gitdir + * @param {string} args.ref + * @param {number} [args.depth] + * @returns {Promise} + */ + static async resolve({ fs, gitdir, ref, depth = void 0 }) { + if (depth !== void 0) { + depth--; + if (depth === -1) { + return ref; + } + } + let sha; + if (ref.startsWith("ref: ")) { + ref = ref.slice("ref: ".length); + return _GitRefManager.resolve({ fs, gitdir, ref, depth }); + } + if (ref.length === 40 && /[0-9a-f]{40}/.test(ref)) { + return ref; + } + const packedMap = await _GitRefManager.packedRefs({ fs, gitdir }); + const allpaths = refpaths(ref).filter((p) => !GIT_FILES.includes(p)); + for (const ref2 of allpaths) { + sha = await fs.read(`${gitdir}/${ref2}`, { encoding: "utf8" }) || packedMap.get(ref2); + if (sha) { + return _GitRefManager.resolve({ fs, gitdir, ref: sha.trim(), depth }); + } + } + throw new NotFoundError(ref); + } + static async exists({ fs, gitdir, ref }) { + try { + await _GitRefManager.expand({ fs, gitdir, ref }); + return true; + } catch (err) { + return false; + } + } + static async expand({ fs, gitdir, ref }) { + if (ref.length === 40 && /[0-9a-f]{40}/.test(ref)) { + return ref; + } + const packedMap = await _GitRefManager.packedRefs({ fs, gitdir }); + const allpaths = refpaths(ref); + for (const ref2 of allpaths) { + if (await fs.exists(`${gitdir}/${ref2}`)) + return ref2; + if (packedMap.has(ref2)) + return ref2; + } + throw new NotFoundError(ref); + } + static async expandAgainstMap({ ref, map }) { + const allpaths = refpaths(ref); + for (const ref2 of allpaths) { + if (await map.has(ref2)) + return ref2; + } + throw new NotFoundError(ref); + } + static resolveAgainstMap({ ref, fullref = ref, depth = void 0, map }) { + if (depth !== void 0) { + depth--; + if (depth === -1) { + return { fullref, oid: ref }; + } + } + if (ref.startsWith("ref: ")) { + ref = ref.slice("ref: ".length); + return _GitRefManager.resolveAgainstMap({ ref, fullref, depth, map }); + } + if (ref.length === 40 && /[0-9a-f]{40}/.test(ref)) { + return { fullref, oid: ref }; + } + const allpaths = refpaths(ref); + for (const ref2 of allpaths) { + const sha = map.get(ref2); + if (sha) { + return _GitRefManager.resolveAgainstMap({ + ref: sha.trim(), + fullref: ref2, + depth, + map + }); + } + } + throw new NotFoundError(ref); + } + static async packedRefs({ fs, gitdir }) { + const text2 = await fs.read(`${gitdir}/packed-refs`, { encoding: "utf8" }); + const packed = GitPackedRefs.from(text2); + return packed.refs; + } + // List all the refs that match the `filepath` prefix + static async listRefs({ fs, gitdir, filepath }) { + const packedMap = _GitRefManager.packedRefs({ fs, gitdir }); + let files = null; + try { + files = await fs.readdirDeep(`${gitdir}/${filepath}`); + files = files.map((x) => x.replace(`${gitdir}/${filepath}/`, "")); + } catch (err) { + files = []; + } + for (let key2 of (await packedMap).keys()) { + if (key2.startsWith(filepath)) { + key2 = key2.replace(filepath + "/", ""); + if (!files.includes(key2)) { + files.push(key2); + } + } + } + files.sort(compareRefNames); + return files; + } + static async listBranches({ fs, gitdir, remote }) { + if (remote) { + return _GitRefManager.listRefs({ + fs, + gitdir, + filepath: `refs/remotes/${remote}` + }); + } else { + return _GitRefManager.listRefs({ fs, gitdir, filepath: `refs/heads` }); + } + } + static async listTags({ fs, gitdir }) { + const tags = await _GitRefManager.listRefs({ + fs, + gitdir, + filepath: `refs/tags` + }); + return tags.filter((x) => !x.endsWith("^{}")); + } +}; +function compareTreeEntryPath(a, b) { + return compareStrings(appendSlashIfDir(a), appendSlashIfDir(b)); +} +function appendSlashIfDir(entry) { + return entry.mode === "040000" ? entry.path + "/" : entry.path; +} +function mode2type$1(mode) { + switch (mode) { + case "040000": + return "tree"; + case "100644": + return "blob"; + case "100755": + return "blob"; + case "120000": + return "blob"; + case "160000": + return "commit"; + } + throw new InternalError(`Unexpected GitTree entry mode: ${mode}`); +} +function parseBuffer(buffer2) { + const _entries = []; + let cursor = 0; + while (cursor < buffer2.length) { + const space2 = buffer2.indexOf(32, cursor); + if (space2 === -1) { + throw new InternalError( + `GitTree: Error parsing buffer at byte location ${cursor}: Could not find the next space character.` + ); + } + const nullchar = buffer2.indexOf(0, cursor); + if (nullchar === -1) { + throw new InternalError( + `GitTree: Error parsing buffer at byte location ${cursor}: Could not find the next null character.` + ); + } + let mode = buffer2.slice(cursor, space2).toString("utf8"); + if (mode === "40000") + mode = "040000"; + const type = mode2type$1(mode); + const path2 = buffer2.slice(space2 + 1, nullchar).toString("utf8"); + if (path2.includes("\\") || path2.includes("/")) { + throw new UnsafeFilepathError(path2); + } + const oid = buffer2.slice(nullchar + 1, nullchar + 21).toString("hex"); + cursor = nullchar + 21; + _entries.push({ mode, path: path2, oid, type }); + } + return _entries; +} +function limitModeToAllowed(mode) { + if (typeof mode === "number") { + mode = mode.toString(8); + } + if (mode.match(/^0?4.*/)) + return "040000"; + if (mode.match(/^1006.*/)) + return "100644"; + if (mode.match(/^1007.*/)) + return "100755"; + if (mode.match(/^120.*/)) + return "120000"; + if (mode.match(/^160.*/)) + return "160000"; + throw new InternalError(`Could not understand file mode: ${mode}`); +} +function nudgeIntoShape(entry) { + if (!entry.oid && entry.sha) { + entry.oid = entry.sha; + } + entry.mode = limitModeToAllowed(entry.mode); + if (!entry.type) { + entry.type = mode2type$1(entry.mode); + } + return entry; +} +var GitTree = class _GitTree { + constructor(entries) { + if (Buffer.isBuffer(entries)) { + this._entries = parseBuffer(entries); + } else if (Array.isArray(entries)) { + this._entries = entries.map(nudgeIntoShape); + } else { + throw new InternalError("invalid type passed to GitTree constructor"); + } + this._entries.sort(comparePath); + } + static from(tree) { + return new _GitTree(tree); + } + render() { + return this._entries.map((entry) => `${entry.mode} ${entry.type} ${entry.oid} ${entry.path}`).join("\n"); + } + toObject() { + const entries = [...this._entries]; + entries.sort(compareTreeEntryPath); + return Buffer.concat( + entries.map((entry) => { + const mode = Buffer.from(entry.mode.replace(/^0/, "")); + const space2 = Buffer.from(" "); + const path2 = Buffer.from(entry.path, "utf8"); + const nullchar = Buffer.from([0]); + const oid = Buffer.from(entry.oid, "hex"); + return Buffer.concat([mode, space2, path2, nullchar, oid]); + }) + ); + } + /** + * @returns {TreeEntry[]} + */ + entries() { + return this._entries; + } + *[Symbol.iterator]() { + for (const entry of this._entries) { + yield entry; + } + } +}; +var GitObject = class { + static wrap({ type, object }) { + return Buffer.concat([ + Buffer.from(`${type} ${object.byteLength.toString()}\0`), + Buffer.from(object) + ]); + } + static unwrap(buffer2) { + const s = buffer2.indexOf(32); + const i = buffer2.indexOf(0); + const type = buffer2.slice(0, s).toString("utf8"); + const length = buffer2.slice(s + 1, i).toString("utf8"); + const actualLength = buffer2.length - (i + 1); + if (parseInt(length) !== actualLength) { + throw new InternalError( + `Length mismatch: expected ${length} bytes but got ${actualLength} instead.` + ); + } + return { + type, + object: Buffer.from(buffer2.slice(i + 1)) + }; + } +}; +async function readObjectLoose({ fs, gitdir, oid }) { + const source = `objects/${oid.slice(0, 2)}/${oid.slice(2)}`; + const file = await fs.read(`${gitdir}/${source}`); + if (!file) { + return null; + } + return { object: file, format: "deflated", source }; +} +function applyDelta(delta, source) { + const reader = new BufferCursor(delta); + const sourceSize = readVarIntLE(reader); + if (sourceSize !== source.byteLength) { + throw new InternalError( + `applyDelta expected source buffer to be ${sourceSize} bytes but the provided buffer was ${source.length} bytes` + ); + } + const targetSize = readVarIntLE(reader); + let target; + const firstOp = readOp(reader, source); + if (firstOp.byteLength === targetSize) { + target = firstOp; + } else { + target = Buffer.alloc(targetSize); + const writer = new BufferCursor(target); + writer.copy(firstOp); + while (!reader.eof()) { + writer.copy(readOp(reader, source)); + } + const tell = writer.tell(); + if (targetSize !== tell) { + throw new InternalError( + `applyDelta expected target buffer to be ${targetSize} bytes but the resulting buffer was ${tell} bytes` + ); + } + } + return target; +} +function readVarIntLE(reader) { + let result = 0; + let shift = 0; + let byte = null; + do { + byte = reader.readUInt8(); + result |= (byte & 127) << shift; + shift += 7; + } while (byte & 128); + return result; +} +function readCompactLE(reader, flags, size) { + let result = 0; + let shift = 0; + while (size--) { + if (flags & 1) { + result |= reader.readUInt8() << shift; + } + flags >>= 1; + shift += 8; + } + return result; +} +function readOp(reader, source) { + const byte = reader.readUInt8(); + const COPY = 128; + const OFFS = 15; + const SIZE = 112; + if (byte & COPY) { + const offset = readCompactLE(reader, byte & OFFS, 4); + let size = readCompactLE(reader, (byte & SIZE) >> 4, 3); + if (size === 0) + size = 65536; + return source.slice(offset, offset + size); + } else { + return reader.slice(byte); + } +} +function fromValue(value) { + let queue = [value]; + return { + next() { + return Promise.resolve({ done: queue.length === 0, value: queue.pop() }); + }, + return() { + queue = []; + return {}; + }, + [Symbol.asyncIterator]() { + return this; + } + }; +} +function getIterator(iterable) { + if (iterable[Symbol.asyncIterator]) { + return iterable[Symbol.asyncIterator](); + } + if (iterable[Symbol.iterator]) { + return iterable[Symbol.iterator](); + } + if (iterable.next) { + return iterable; + } + return fromValue(iterable); +} +var StreamReader = class { + constructor(stream) { + this.stream = getIterator(stream); + this.buffer = null; + this.cursor = 0; + this.undoCursor = 0; + this.started = false; + this._ended = false; + this._discardedBytes = 0; + } + eof() { + return this._ended && this.cursor === this.buffer.length; + } + tell() { + return this._discardedBytes + this.cursor; + } + async byte() { + if (this.eof()) + return; + if (!this.started) + await this._init(); + if (this.cursor === this.buffer.length) { + await this._loadnext(); + if (this._ended) + return; + } + this._moveCursor(1); + return this.buffer[this.undoCursor]; + } + async chunk() { + if (this.eof()) + return; + if (!this.started) + await this._init(); + if (this.cursor === this.buffer.length) { + await this._loadnext(); + if (this._ended) + return; + } + this._moveCursor(this.buffer.length); + return this.buffer.slice(this.undoCursor, this.cursor); + } + async read(n) { + if (this.eof()) + return; + if (!this.started) + await this._init(); + if (this.cursor + n > this.buffer.length) { + this._trim(); + await this._accumulate(n); + } + this._moveCursor(n); + return this.buffer.slice(this.undoCursor, this.cursor); + } + async skip(n) { + if (this.eof()) + return; + if (!this.started) + await this._init(); + if (this.cursor + n > this.buffer.length) { + this._trim(); + await this._accumulate(n); + } + this._moveCursor(n); + } + async undo() { + this.cursor = this.undoCursor; + } + async _next() { + this.started = true; + let { done, value } = await this.stream.next(); + if (done) { + this._ended = true; + } + if (value) { + value = Buffer.from(value); + } + return value; + } + _trim() { + this.buffer = this.buffer.slice(this.undoCursor); + this.cursor -= this.undoCursor; + this._discardedBytes += this.undoCursor; + this.undoCursor = 0; + } + _moveCursor(n) { + this.undoCursor = this.cursor; + this.cursor += n; + if (this.cursor > this.buffer.length) { + this.cursor = this.buffer.length; + } + } + async _accumulate(n) { + if (this._ended) + return; + const buffers = [this.buffer]; + while (this.cursor + n > lengthBuffers(buffers)) { + const nextbuffer = await this._next(); + if (this._ended) + break; + buffers.push(nextbuffer); + } + this.buffer = Buffer.concat(buffers); + } + async _loadnext() { + this._discardedBytes += this.buffer.length; + this.undoCursor = 0; + this.cursor = 0; + this.buffer = await this._next(); + } + async _init() { + this.buffer = await this._next(); + } +}; +function lengthBuffers(buffers) { + return buffers.reduce((acc, buffer2) => acc + buffer2.length, 0); +} +async function listpack(stream, onData) { + const reader = new StreamReader(stream); + let PACK = await reader.read(4); + PACK = PACK.toString("utf8"); + if (PACK !== "PACK") { + throw new InternalError(`Invalid PACK header '${PACK}'`); + } + let version2 = await reader.read(4); + version2 = version2.readUInt32BE(0); + if (version2 !== 2) { + throw new InternalError(`Invalid packfile version: ${version2}`); + } + let numObjects = await reader.read(4); + numObjects = numObjects.readUInt32BE(0); + if (numObjects < 1) + return; + while (!reader.eof() && numObjects--) { + const offset = reader.tell(); + const { type, length, ofs, reference } = await parseHeader(reader); + const inflator = new import_pako.default.Inflate(); + while (!inflator.result) { + const chunk = await reader.chunk(); + if (!chunk) + break; + inflator.push(chunk, false); + if (inflator.err) { + throw new InternalError(`Pako error: ${inflator.msg}`); + } + if (inflator.result) { + if (inflator.result.length !== length) { + throw new InternalError( + `Inflated object size is different from that stated in packfile.` + ); + } + await reader.undo(); + await reader.read(chunk.length - inflator.strm.avail_in); + const end = reader.tell(); + await onData({ + data: inflator.result, + type, + num: numObjects, + offset, + end, + reference, + ofs + }); + } + } + } +} +async function parseHeader(reader) { + let byte = await reader.byte(); + const type = byte >> 4 & 7; + let length = byte & 15; + if (byte & 128) { + let shift = 4; + do { + byte = await reader.byte(); + length |= (byte & 127) << shift; + shift += 7; + } while (byte & 128); + } + let ofs; + let reference; + if (type === 6) { + let shift = 0; + ofs = 0; + const bytes = []; + do { + byte = await reader.byte(); + ofs |= (byte & 127) << shift; + shift += 7; + bytes.push(byte); + } while (byte & 128); + reference = Buffer.from(bytes); + } + if (type === 7) { + const buf = await reader.read(20); + reference = buf; + } + return { type, length, ofs, reference }; +} +var supportsDecompressionStream = false; +async function inflate(buffer2) { + if (supportsDecompressionStream === null) { + supportsDecompressionStream = testDecompressionStream(); + } + return supportsDecompressionStream ? browserInflate(buffer2) : import_pako.default.inflate(buffer2); +} +async function browserInflate(buffer2) { + const ds = new DecompressionStream("deflate"); + const d = new Blob([buffer2]).stream().pipeThrough(ds); + return new Uint8Array(await new Response(d).arrayBuffer()); +} +function testDecompressionStream() { + try { + const ds = new DecompressionStream("deflate"); + if (ds) + return true; + } catch (_) { + } + return false; +} +function decodeVarInt(reader) { + const bytes = []; + let byte = 0; + let multibyte = 0; + do { + byte = reader.readUInt8(); + const lastSeven = byte & 127; + bytes.push(lastSeven); + multibyte = byte & 128; + } while (multibyte); + return bytes.reduce((a, b) => a + 1 << 7 | b, -1); +} +function otherVarIntDecode(reader, startWith) { + let result = startWith; + let shift = 4; + let byte = null; + do { + byte = reader.readUInt8(); + result |= (byte & 127) << shift; + shift += 7; + } while (byte & 128); + return result; +} +var GitPackIndex = class _GitPackIndex { + constructor(stuff) { + Object.assign(this, stuff); + this.offsetCache = {}; + } + static async fromIdx({ idx, getExternalRefDelta }) { + const reader = new BufferCursor(idx); + const magic = reader.slice(4).toString("hex"); + if (magic !== "ff744f63") { + return; + } + const version2 = reader.readUInt32BE(); + if (version2 !== 2) { + throw new InternalError( + `Unable to read version ${version2} packfile IDX. (Only version 2 supported)` + ); + } + if (idx.byteLength > 2048 * 1024 * 1024) { + throw new InternalError( + `To keep implementation simple, I haven't implemented the layer 5 feature needed to support packfiles > 2GB in size.` + ); + } + reader.seek(reader.tell() + 4 * 255); + const size = reader.readUInt32BE(); + const hashes = []; + for (let i = 0; i < size; i++) { + const hash2 = reader.slice(20).toString("hex"); + hashes[i] = hash2; + } + reader.seek(reader.tell() + 4 * size); + const offsets = /* @__PURE__ */ new Map(); + for (let i = 0; i < size; i++) { + offsets.set(hashes[i], reader.readUInt32BE()); + } + const packfileSha = reader.slice(20).toString("hex"); + return new _GitPackIndex({ + hashes, + crcs: {}, + offsets, + packfileSha, + getExternalRefDelta + }); + } + static async fromPack({ pack, getExternalRefDelta, onProgress }) { + const listpackTypes = { + 1: "commit", + 2: "tree", + 3: "blob", + 4: "tag", + 6: "ofs-delta", + 7: "ref-delta" + }; + const offsetToObject = {}; + const packfileSha = pack.slice(-20).toString("hex"); + const hashes = []; + const crcs = {}; + const offsets = /* @__PURE__ */ new Map(); + let totalObjectCount = null; + let lastPercent = null; + await listpack([pack], async ({ data, type, reference, offset, num: num2 }) => { + if (totalObjectCount === null) + totalObjectCount = num2; + const percent = Math.floor( + (totalObjectCount - num2) * 100 / totalObjectCount + ); + if (percent !== lastPercent) { + if (onProgress) { + await onProgress({ + phase: "Receiving objects", + loaded: totalObjectCount - num2, + total: totalObjectCount + }); + } + } + lastPercent = percent; + type = listpackTypes[type]; + if (["commit", "tree", "blob", "tag"].includes(type)) { + offsetToObject[offset] = { + type, + offset + }; + } else if (type === "ofs-delta") { + offsetToObject[offset] = { + type, + offset + }; + } else if (type === "ref-delta") { + offsetToObject[offset] = { + type, + offset + }; + } + }); + const offsetArray = Object.keys(offsetToObject).map(Number); + for (const [i, start] of offsetArray.entries()) { + const end = i + 1 === offsetArray.length ? pack.byteLength - 20 : offsetArray[i + 1]; + const o = offsetToObject[start]; + const crc = import_crc_32.default.buf(pack.slice(start, end)) >>> 0; + o.end = end; + o.crc = crc; + } + const p = new _GitPackIndex({ + pack: Promise.resolve(pack), + packfileSha, + crcs, + hashes, + offsets, + getExternalRefDelta + }); + lastPercent = null; + let count = 0; + const objectsByDepth = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; + for (let offset in offsetToObject) { + offset = Number(offset); + const percent = Math.floor(count * 100 / totalObjectCount); + if (percent !== lastPercent) { + if (onProgress) { + await onProgress({ + phase: "Resolving deltas", + loaded: count, + total: totalObjectCount + }); + } + } + count++; + lastPercent = percent; + const o = offsetToObject[offset]; + if (o.oid) + continue; + try { + p.readDepth = 0; + p.externalReadDepth = 0; + const { type, object } = await p.readSlice({ start: offset }); + objectsByDepth[p.readDepth] += 1; + const oid = await shasum(GitObject.wrap({ type, object })); + o.oid = oid; + hashes.push(oid); + offsets.set(oid, offset); + crcs[oid] = o.crc; + } catch (err) { + continue; + } + } + hashes.sort(); + return p; + } + async toBuffer() { + const buffers = []; + const write = (str, encoding) => { + buffers.push(Buffer.from(str, encoding)); + }; + write("ff744f63", "hex"); + write("00000002", "hex"); + const fanoutBuffer = new BufferCursor(Buffer.alloc(256 * 4)); + for (let i = 0; i < 256; i++) { + let count = 0; + for (const hash2 of this.hashes) { + if (parseInt(hash2.slice(0, 2), 16) <= i) + count++; + } + fanoutBuffer.writeUInt32BE(count); + } + buffers.push(fanoutBuffer.buffer); + for (const hash2 of this.hashes) { + write(hash2, "hex"); + } + const crcsBuffer = new BufferCursor(Buffer.alloc(this.hashes.length * 4)); + for (const hash2 of this.hashes) { + crcsBuffer.writeUInt32BE(this.crcs[hash2]); + } + buffers.push(crcsBuffer.buffer); + const offsetsBuffer = new BufferCursor(Buffer.alloc(this.hashes.length * 4)); + for (const hash2 of this.hashes) { + offsetsBuffer.writeUInt32BE(this.offsets.get(hash2)); + } + buffers.push(offsetsBuffer.buffer); + write(this.packfileSha, "hex"); + const totalBuffer = Buffer.concat(buffers); + const sha = await shasum(totalBuffer); + const shaBuffer = Buffer.alloc(20); + shaBuffer.write(sha, "hex"); + return Buffer.concat([totalBuffer, shaBuffer]); + } + async load({ pack }) { + this.pack = pack; + } + async unload() { + this.pack = null; + } + async read({ oid }) { + if (!this.offsets.get(oid)) { + if (this.getExternalRefDelta) { + this.externalReadDepth++; + return this.getExternalRefDelta(oid); + } else { + throw new InternalError(`Could not read object ${oid} from packfile`); + } + } + const start = this.offsets.get(oid); + return this.readSlice({ start }); + } + async readSlice({ start }) { + if (this.offsetCache[start]) { + return Object.assign({}, this.offsetCache[start]); + } + this.readDepth++; + const types2 = { + 16: "commit", + 32: "tree", + 48: "blob", + 64: "tag", + 96: "ofs_delta", + 112: "ref_delta" + }; + if (!this.pack) { + throw new InternalError( + "Tried to read from a GitPackIndex with no packfile loaded into memory" + ); + } + const raw = (await this.pack).slice(start); + const reader = new BufferCursor(raw); + const byte = reader.readUInt8(); + const btype = byte & 112; + let type = types2[btype]; + if (type === void 0) { + throw new InternalError("Unrecognized type: 0b" + btype.toString(2)); + } + const lastFour = byte & 15; + let length = lastFour; + const multibyte = byte & 128; + if (multibyte) { + length = otherVarIntDecode(reader, lastFour); + } + let base = null; + let object = null; + if (type === "ofs_delta") { + const offset = decodeVarInt(reader); + const baseOffset = start - offset; + ({ object: base, type } = await this.readSlice({ start: baseOffset })); + } + if (type === "ref_delta") { + const oid = reader.slice(20).toString("hex"); + ({ object: base, type } = await this.read({ oid })); + } + const buffer2 = raw.slice(reader.tell()); + object = Buffer.from(await inflate(buffer2)); + if (object.byteLength !== length) { + throw new InternalError( + `Packfile told us object would have length ${length} but it had length ${object.byteLength}` + ); + } + if (base) { + object = Buffer.from(applyDelta(object, base)); + } + if (this.readDepth > 3) { + this.offsetCache[start] = { type, object }; + } + return { type, format: "content", object }; + } +}; +var PackfileCache = Symbol("PackfileCache"); +async function loadPackIndex({ + fs, + filename, + getExternalRefDelta, + emitter, + emitterPrefix +}) { + const idx = await fs.read(filename); + return GitPackIndex.fromIdx({ idx, getExternalRefDelta }); +} +function readPackIndex({ + fs, + cache, + filename, + getExternalRefDelta, + emitter, + emitterPrefix +}) { + if (!cache[PackfileCache]) + cache[PackfileCache] = /* @__PURE__ */ new Map(); + let p = cache[PackfileCache].get(filename); + if (!p) { + p = loadPackIndex({ + fs, + filename, + getExternalRefDelta, + emitter, + emitterPrefix + }); + cache[PackfileCache].set(filename, p); + } + return p; +} +async function readObjectPacked({ + fs, + cache, + gitdir, + oid, + format = "content", + getExternalRefDelta +}) { + let list = await fs.readdir(join(gitdir, "objects/pack")); + list = list.filter((x) => x.endsWith(".idx")); + for (const filename of list) { + const indexFile = `${gitdir}/objects/pack/${filename}`; + const p = await readPackIndex({ + fs, + cache, + filename: indexFile, + getExternalRefDelta + }); + if (p.error) + throw new InternalError(p.error); + if (p.offsets.has(oid)) { + if (!p.pack) { + const packFile = indexFile.replace(/idx$/, "pack"); + p.pack = fs.read(packFile); + } + const result = await p.read({ oid, getExternalRefDelta }); + result.format = "content"; + result.source = `objects/pack/${filename.replace(/idx$/, "pack")}`; + return result; + } + } + return null; +} +async function _readObject({ + fs, + cache, + gitdir, + oid, + format = "content" +}) { + const getExternalRefDelta = (oid2) => _readObject({ fs, cache, gitdir, oid: oid2 }); + let result; + if (oid === "4b825dc642cb6eb9a060e54bf8d69288fbee4904") { + result = { format: "wrapped", object: Buffer.from(`tree 0\0`) }; + } + if (!result) { + result = await readObjectLoose({ fs, gitdir, oid }); + } + if (!result) { + result = await readObjectPacked({ + fs, + cache, + gitdir, + oid, + getExternalRefDelta + }); + } + if (!result) { + throw new NotFoundError(oid); + } + if (format === "deflated") { + return result; + } + if (result.format === "deflated") { + result.object = Buffer.from(await inflate(result.object)); + result.format = "wrapped"; + } + if (result.format === "wrapped") { + if (format === "wrapped" && result.format === "wrapped") { + return result; + } + const sha = await shasum(result.object); + if (sha !== oid) { + throw new InternalError( + `SHA check failed! Expected ${oid}, computed ${sha}` + ); + } + const { object, type } = GitObject.unwrap(result.object); + result.type = type; + result.object = object; + result.format = "content"; + } + if (result.format === "content") { + if (format === "content") + return result; + return; + } + throw new InternalError(`invalid format "${result.format}"`); +} +var AlreadyExistsError = class _AlreadyExistsError extends BaseError { + /** + * @param {'note'|'remote'|'tag'|'branch'} noun + * @param {string} where + * @param {boolean} canForce + */ + constructor(noun, where, canForce = true) { + super( + `Failed to create ${noun} at ${where} because it already exists.${canForce ? ` (Hint: use 'force: true' parameter to overwrite existing ${noun}.)` : ""}` + ); + this.code = this.name = _AlreadyExistsError.code; + this.data = { noun, where, canForce }; + } +}; +AlreadyExistsError.code = "AlreadyExistsError"; +var AmbiguousError = class _AmbiguousError extends BaseError { + /** + * @param {'oids'|'refs'} nouns + * @param {string} short + * @param {string[]} matches + */ + constructor(nouns, short, matches) { + super( + `Found multiple ${nouns} matching "${short}" (${matches.join( + ", " + )}). Use a longer abbreviation length to disambiguate them.` + ); + this.code = this.name = _AmbiguousError.code; + this.data = { nouns, short, matches }; + } +}; +AmbiguousError.code = "AmbiguousError"; +var CheckoutConflictError = class _CheckoutConflictError extends BaseError { + /** + * @param {string[]} filepaths + */ + constructor(filepaths) { + super( + `Your local changes to the following files would be overwritten by checkout: ${filepaths.join( + ", " + )}` + ); + this.code = this.name = _CheckoutConflictError.code; + this.data = { filepaths }; + } +}; +CheckoutConflictError.code = "CheckoutConflictError"; +var CommitNotFetchedError = class _CommitNotFetchedError extends BaseError { + /** + * @param {string} ref + * @param {string} oid + */ + constructor(ref, oid) { + super( + `Failed to checkout "${ref}" because commit ${oid} is not available locally. Do a git fetch to make the branch available locally.` + ); + this.code = this.name = _CommitNotFetchedError.code; + this.data = { ref, oid }; + } +}; +CommitNotFetchedError.code = "CommitNotFetchedError"; +var EmptyServerResponseError = class _EmptyServerResponseError extends BaseError { + constructor() { + super(`Empty response from git server.`); + this.code = this.name = _EmptyServerResponseError.code; + this.data = {}; + } +}; +EmptyServerResponseError.code = "EmptyServerResponseError"; +var FastForwardError = class _FastForwardError extends BaseError { + constructor() { + super(`A simple fast-forward merge was not possible.`); + this.code = this.name = _FastForwardError.code; + this.data = {}; + } +}; +FastForwardError.code = "FastForwardError"; +var GitPushError = class _GitPushError extends BaseError { + /** + * @param {string} prettyDetails + * @param {PushResult} result + */ + constructor(prettyDetails, result) { + super(`One or more branches were not updated: ${prettyDetails}`); + this.code = this.name = _GitPushError.code; + this.data = { prettyDetails, result }; + } +}; +GitPushError.code = "GitPushError"; +var HttpError = class _HttpError extends BaseError { + /** + * @param {number} statusCode + * @param {string} statusMessage + * @param {string} response + */ + constructor(statusCode, statusMessage, response) { + super(`HTTP Error: ${statusCode} ${statusMessage}`); + this.code = this.name = _HttpError.code; + this.data = { statusCode, statusMessage, response }; + } +}; +HttpError.code = "HttpError"; +var InvalidFilepathError = class _InvalidFilepathError extends BaseError { + /** + * @param {'leading-slash'|'trailing-slash'|'directory'} [reason] + */ + constructor(reason) { + let message = "invalid filepath"; + if (reason === "leading-slash" || reason === "trailing-slash") { + message = `"filepath" parameter should not include leading or trailing directory separators because these can cause problems on some platforms.`; + } else if (reason === "directory") { + message = `"filepath" should not be a directory.`; + } + super(message); + this.code = this.name = _InvalidFilepathError.code; + this.data = { reason }; + } +}; +InvalidFilepathError.code = "InvalidFilepathError"; +var InvalidRefNameError = class _InvalidRefNameError extends BaseError { + /** + * @param {string} ref + * @param {string} suggestion + * @param {boolean} canForce + */ + constructor(ref, suggestion) { + super( + `"${ref}" would be an invalid git reference. (Hint: a valid alternative would be "${suggestion}".)` + ); + this.code = this.name = _InvalidRefNameError.code; + this.data = { ref, suggestion }; + } +}; +InvalidRefNameError.code = "InvalidRefNameError"; +var MaxDepthError = class _MaxDepthError extends BaseError { + /** + * @param {number} depth + */ + constructor(depth) { + super(`Maximum search depth of ${depth} exceeded.`); + this.code = this.name = _MaxDepthError.code; + this.data = { depth }; + } +}; +MaxDepthError.code = "MaxDepthError"; +var MergeNotSupportedError = class _MergeNotSupportedError extends BaseError { + constructor() { + super(`Merges with conflicts are not supported yet.`); + this.code = this.name = _MergeNotSupportedError.code; + this.data = {}; + } +}; +MergeNotSupportedError.code = "MergeNotSupportedError"; +var MergeConflictError = class _MergeConflictError extends BaseError { + /** + * @param {Array} filepaths + */ + constructor(filepaths) { + super( + `Automatic merge failed with one or more merge conflicts in the following files: ${filepaths.toString()}. Fix conflicts then commit the result.` + ); + this.code = this.name = _MergeConflictError.code; + this.data = { filepaths }; + } +}; +MergeConflictError.code = "MergeConflictError"; +var MissingNameError = class _MissingNameError extends BaseError { + /** + * @param {'author'|'committer'|'tagger'} role + */ + constructor(role) { + super( + `No name was provided for ${role} in the argument or in the .git/config file.` + ); + this.code = this.name = _MissingNameError.code; + this.data = { role }; + } +}; +MissingNameError.code = "MissingNameError"; +var MissingParameterError = class _MissingParameterError extends BaseError { + /** + * @param {string} parameter + */ + constructor(parameter) { + super( + `The function requires a "${parameter}" parameter but none was provided.` + ); + this.code = this.name = _MissingParameterError.code; + this.data = { parameter }; + } +}; +MissingParameterError.code = "MissingParameterError"; +var MultipleGitError = class _MultipleGitError extends BaseError { + /** + * @param {Error[]} errors + * @param {string} message + */ + constructor(errors) { + super( + `There are multiple errors that were thrown by the method. Please refer to the "errors" property to see more` + ); + this.code = this.name = _MultipleGitError.code; + this.data = { errors }; + this.errors = errors; + } +}; +MultipleGitError.code = "MultipleGitError"; +var ParseError = class _ParseError extends BaseError { + /** + * @param {string} expected + * @param {string} actual + */ + constructor(expected, actual) { + super(`Expected "${expected}" but received "${actual}".`); + this.code = this.name = _ParseError.code; + this.data = { expected, actual }; + } +}; +ParseError.code = "ParseError"; +var PushRejectedError = class _PushRejectedError extends BaseError { + /** + * @param {'not-fast-forward'|'tag-exists'} reason + */ + constructor(reason) { + let message = ""; + if (reason === "not-fast-forward") { + message = " because it was not a simple fast-forward"; + } else if (reason === "tag-exists") { + message = " because tag already exists"; + } + super(`Push rejected${message}. Use "force: true" to override.`); + this.code = this.name = _PushRejectedError.code; + this.data = { reason }; + } +}; +PushRejectedError.code = "PushRejectedError"; +var RemoteCapabilityError = class _RemoteCapabilityError extends BaseError { + /** + * @param {'shallow'|'deepen-since'|'deepen-not'|'deepen-relative'} capability + * @param {'depth'|'since'|'exclude'|'relative'} parameter + */ + constructor(capability, parameter) { + super( + `Remote does not support the "${capability}" so the "${parameter}" parameter cannot be used.` + ); + this.code = this.name = _RemoteCapabilityError.code; + this.data = { capability, parameter }; + } +}; +RemoteCapabilityError.code = "RemoteCapabilityError"; +var SmartHttpError = class _SmartHttpError extends BaseError { + /** + * @param {string} preview + * @param {string} response + */ + constructor(preview, response) { + super( + `Remote did not reply using the "smart" HTTP protocol. Expected "001e# service=git-upload-pack" but received: ${preview}` + ); + this.code = this.name = _SmartHttpError.code; + this.data = { preview, response }; + } +}; +SmartHttpError.code = "SmartHttpError"; +var UnknownTransportError = class _UnknownTransportError extends BaseError { + /** + * @param {string} url + * @param {string} transport + * @param {string} [suggestion] + */ + constructor(url, transport, suggestion) { + super( + `Git remote "${url}" uses an unrecognized transport protocol: "${transport}"` + ); + this.code = this.name = _UnknownTransportError.code; + this.data = { url, transport, suggestion }; + } +}; +UnknownTransportError.code = "UnknownTransportError"; +var UrlParseError = class _UrlParseError extends BaseError { + /** + * @param {string} url + */ + constructor(url) { + super(`Cannot parse remote URL: "${url}"`); + this.code = this.name = _UrlParseError.code; + this.data = { url }; + } +}; +UrlParseError.code = "UrlParseError"; +var UserCanceledError = class _UserCanceledError extends BaseError { + constructor() { + super(`The operation was canceled.`); + this.code = this.name = _UserCanceledError.code; + this.data = {}; + } +}; +UserCanceledError.code = "UserCanceledError"; +var IndexResetError = class _IndexResetError extends BaseError { + /** + * @param {Array} filepaths + */ + constructor(filepath) { + super( + `Could not merge index: Entry for '${filepath}' is not up to date. Either reset the index entry to HEAD, or stage your unstaged chages.` + ); + this.code = this.name = _IndexResetError.code; + this.data = { filepath }; + } +}; +IndexResetError.code = "IndexResetError"; +var Errors = /* @__PURE__ */ Object.freeze({ + __proto__: null, + AlreadyExistsError, + AmbiguousError, + CheckoutConflictError, + CommitNotFetchedError, + EmptyServerResponseError, + FastForwardError, + GitPushError, + HttpError, + InternalError, + InvalidFilepathError, + InvalidOidError, + InvalidRefNameError, + MaxDepthError, + MergeNotSupportedError, + MergeConflictError, + MissingNameError, + MissingParameterError, + MultipleGitError, + NoRefspecError, + NotFoundError, + ObjectTypeError, + ParseError, + PushRejectedError, + RemoteCapabilityError, + SmartHttpError, + UnknownTransportError, + UnsafeFilepathError, + UrlParseError, + UserCanceledError, + UnmergedPathsError, + IndexResetError +}); +function formatAuthor({ name, email, timestamp, timezoneOffset }) { + timezoneOffset = formatTimezoneOffset(timezoneOffset); + return `${name} <${email}> ${timestamp} ${timezoneOffset}`; +} +function formatTimezoneOffset(minutes) { + const sign = simpleSign(negateExceptForZero(minutes)); + minutes = Math.abs(minutes); + const hours = Math.floor(minutes / 60); + minutes -= hours * 60; + let strHours = String(hours); + let strMinutes = String(minutes); + if (strHours.length < 2) + strHours = "0" + strHours; + if (strMinutes.length < 2) + strMinutes = "0" + strMinutes; + return (sign === -1 ? "-" : "+") + strHours + strMinutes; +} +function simpleSign(n) { + return Math.sign(n) || (Object.is(n, -0) ? -1 : 1); +} +function negateExceptForZero(n) { + return n === 0 ? n : -n; +} +function normalizeNewlines(str) { + str = str.replace(/\r/g, ""); + str = str.replace(/^\n+/, ""); + str = str.replace(/\n+$/, "") + "\n"; + return str; +} +function parseAuthor(author) { + const [, name, email, timestamp, offset] = author.match( + /^(.*) <(.*)> (.*) (.*)$/ + ); + return { + name, + email, + timestamp: Number(timestamp), + timezoneOffset: parseTimezoneOffset(offset) + }; +} +function parseTimezoneOffset(offset) { + let [, sign, hours, minutes] = offset.match(/(\+|-)(\d\d)(\d\d)/); + minutes = (sign === "+" ? 1 : -1) * (Number(hours) * 60 + Number(minutes)); + return negateExceptForZero$1(minutes); +} +function negateExceptForZero$1(n) { + return n === 0 ? n : -n; +} +var GitAnnotatedTag = class _GitAnnotatedTag { + constructor(tag2) { + if (typeof tag2 === "string") { + this._tag = tag2; + } else if (Buffer.isBuffer(tag2)) { + this._tag = tag2.toString("utf8"); + } else if (typeof tag2 === "object") { + this._tag = _GitAnnotatedTag.render(tag2); + } else { + throw new InternalError( + "invalid type passed to GitAnnotatedTag constructor" + ); + } + } + static from(tag2) { + return new _GitAnnotatedTag(tag2); + } + static render(obj) { + return `object ${obj.object} +type ${obj.type} +tag ${obj.tag} +tagger ${formatAuthor(obj.tagger)} + +${obj.message} +${obj.gpgsig ? obj.gpgsig : ""}`; + } + justHeaders() { + return this._tag.slice(0, this._tag.indexOf("\n\n")); + } + message() { + const tag2 = this.withoutSignature(); + return tag2.slice(tag2.indexOf("\n\n") + 2); + } + parse() { + return Object.assign(this.headers(), { + message: this.message(), + gpgsig: this.gpgsig() + }); + } + render() { + return this._tag; + } + headers() { + const headers = this.justHeaders().split("\n"); + const hs = []; + for (const h of headers) { + if (h[0] === " ") { + hs[hs.length - 1] += "\n" + h.slice(1); + } else { + hs.push(h); + } + } + const obj = {}; + for (const h of hs) { + const key2 = h.slice(0, h.indexOf(" ")); + const value = h.slice(h.indexOf(" ") + 1); + if (Array.isArray(obj[key2])) { + obj[key2].push(value); + } else { + obj[key2] = value; + } + } + if (obj.tagger) { + obj.tagger = parseAuthor(obj.tagger); + } + if (obj.committer) { + obj.committer = parseAuthor(obj.committer); + } + return obj; + } + withoutSignature() { + const tag2 = normalizeNewlines(this._tag); + if (tag2.indexOf("\n-----BEGIN PGP SIGNATURE-----") === -1) + return tag2; + return tag2.slice(0, tag2.lastIndexOf("\n-----BEGIN PGP SIGNATURE-----")); + } + gpgsig() { + if (this._tag.indexOf("\n-----BEGIN PGP SIGNATURE-----") === -1) + return; + const signature = this._tag.slice( + this._tag.indexOf("-----BEGIN PGP SIGNATURE-----"), + this._tag.indexOf("-----END PGP SIGNATURE-----") + "-----END PGP SIGNATURE-----".length + ); + return normalizeNewlines(signature); + } + payload() { + return this.withoutSignature() + "\n"; + } + toObject() { + return Buffer.from(this._tag, "utf8"); + } + static async sign(tag2, sign, secretKey) { + const payload = tag2.payload(); + let { signature } = await sign({ payload, secretKey }); + signature = normalizeNewlines(signature); + const signedTag = payload + signature; + return _GitAnnotatedTag.from(signedTag); + } +}; +function indent(str) { + return str.trim().split("\n").map((x) => " " + x).join("\n") + "\n"; +} +function outdent(str) { + return str.split("\n").map((x) => x.replace(/^ /, "")).join("\n"); +} +var GitCommit = class _GitCommit { + constructor(commit2) { + if (typeof commit2 === "string") { + this._commit = commit2; + } else if (Buffer.isBuffer(commit2)) { + this._commit = commit2.toString("utf8"); + } else if (typeof commit2 === "object") { + this._commit = _GitCommit.render(commit2); + } else { + throw new InternalError("invalid type passed to GitCommit constructor"); + } + } + static fromPayloadSignature({ payload, signature }) { + const headers = _GitCommit.justHeaders(payload); + const message = _GitCommit.justMessage(payload); + const commit2 = normalizeNewlines( + headers + "\ngpgsig" + indent(signature) + "\n" + message + ); + return new _GitCommit(commit2); + } + static from(commit2) { + return new _GitCommit(commit2); + } + toObject() { + return Buffer.from(this._commit, "utf8"); + } + // Todo: allow setting the headers and message + headers() { + return this.parseHeaders(); + } + // Todo: allow setting the headers and message + message() { + return _GitCommit.justMessage(this._commit); + } + parse() { + return Object.assign({ message: this.message() }, this.headers()); + } + static justMessage(commit2) { + return normalizeNewlines(commit2.slice(commit2.indexOf("\n\n") + 2)); + } + static justHeaders(commit2) { + return commit2.slice(0, commit2.indexOf("\n\n")); + } + parseHeaders() { + const headers = _GitCommit.justHeaders(this._commit).split("\n"); + const hs = []; + for (const h of headers) { + if (h[0] === " ") { + hs[hs.length - 1] += "\n" + h.slice(1); + } else { + hs.push(h); + } + } + const obj = { + parent: [] + }; + for (const h of hs) { + const key2 = h.slice(0, h.indexOf(" ")); + const value = h.slice(h.indexOf(" ") + 1); + if (Array.isArray(obj[key2])) { + obj[key2].push(value); + } else { + obj[key2] = value; + } + } + if (obj.author) { + obj.author = parseAuthor(obj.author); + } + if (obj.committer) { + obj.committer = parseAuthor(obj.committer); + } + return obj; + } + static renderHeaders(obj) { + let headers = ""; + if (obj.tree) { + headers += `tree ${obj.tree} +`; + } else { + headers += `tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904 +`; + } + if (obj.parent) { + if (obj.parent.length === void 0) { + throw new InternalError(`commit 'parent' property should be an array`); + } + for (const p of obj.parent) { + headers += `parent ${p} +`; + } + } + const author = obj.author; + headers += `author ${formatAuthor(author)} +`; + const committer = obj.committer || obj.author; + headers += `committer ${formatAuthor(committer)} +`; + if (obj.gpgsig) { + headers += "gpgsig" + indent(obj.gpgsig); + } + return headers; + } + static render(obj) { + return _GitCommit.renderHeaders(obj) + "\n" + normalizeNewlines(obj.message); + } + render() { + return this._commit; + } + withoutSignature() { + const commit2 = normalizeNewlines(this._commit); + if (commit2.indexOf("\ngpgsig") === -1) + return commit2; + const headers = commit2.slice(0, commit2.indexOf("\ngpgsig")); + const message = commit2.slice( + commit2.indexOf("-----END PGP SIGNATURE-----\n") + "-----END PGP SIGNATURE-----\n".length + ); + return normalizeNewlines(headers + "\n" + message); + } + isolateSignature() { + const signature = this._commit.slice( + this._commit.indexOf("-----BEGIN PGP SIGNATURE-----"), + this._commit.indexOf("-----END PGP SIGNATURE-----") + "-----END PGP SIGNATURE-----".length + ); + return outdent(signature); + } + static async sign(commit2, sign, secretKey) { + const payload = commit2.withoutSignature(); + const message = _GitCommit.justMessage(commit2._commit); + let { signature } = await sign({ payload, secretKey }); + signature = normalizeNewlines(signature); + const headers = _GitCommit.justHeaders(commit2._commit); + const signedCommit = headers + "\ngpgsig" + indent(signature) + "\n" + message; + return _GitCommit.from(signedCommit); + } +}; +async function resolveTree({ fs, cache, gitdir, oid }) { + if (oid === "4b825dc642cb6eb9a060e54bf8d69288fbee4904") { + return { tree: GitTree.from([]), oid }; + } + const { type, object } = await _readObject({ fs, cache, gitdir, oid }); + if (type === "tag") { + oid = GitAnnotatedTag.from(object).parse().object; + return resolveTree({ fs, cache, gitdir, oid }); + } + if (type === "commit") { + oid = GitCommit.from(object).parse().tree; + return resolveTree({ fs, cache, gitdir, oid }); + } + if (type !== "tree") { + throw new ObjectTypeError(oid, type, "tree"); + } + return { tree: GitTree.from(object), oid }; +} +var GitWalkerRepo = class { + constructor({ fs, gitdir, ref, cache }) { + this.fs = fs; + this.cache = cache; + this.gitdir = gitdir; + this.mapPromise = (async () => { + const map = /* @__PURE__ */ new Map(); + let oid; + try { + oid = await GitRefManager.resolve({ fs, gitdir, ref }); + } catch (e) { + if (e instanceof NotFoundError) { + oid = "4b825dc642cb6eb9a060e54bf8d69288fbee4904"; + } + } + const tree = await resolveTree({ fs, cache: this.cache, gitdir, oid }); + tree.type = "tree"; + tree.mode = "40000"; + map.set(".", tree); + return map; + })(); + const walker = this; + this.ConstructEntry = class TreeEntry { + constructor(fullpath) { + this._fullpath = fullpath; + this._type = false; + this._mode = false; + this._stat = false; + this._content = false; + this._oid = false; + } + async type() { + return walker.type(this); + } + async mode() { + return walker.mode(this); + } + async stat() { + return walker.stat(this); + } + async content() { + return walker.content(this); + } + async oid() { + return walker.oid(this); + } + }; + } + async readdir(entry) { + const filepath = entry._fullpath; + const { fs, cache, gitdir } = this; + const map = await this.mapPromise; + const obj = map.get(filepath); + if (!obj) + throw new Error(`No obj for ${filepath}`); + const oid = obj.oid; + if (!oid) + throw new Error(`No oid for obj ${JSON.stringify(obj)}`); + if (obj.type !== "tree") { + return null; + } + const { type, object } = await _readObject({ fs, cache, gitdir, oid }); + if (type !== obj.type) { + throw new ObjectTypeError(oid, type, obj.type); + } + const tree = GitTree.from(object); + for (const entry2 of tree) { + map.set(join(filepath, entry2.path), entry2); + } + return tree.entries().map((entry2) => join(filepath, entry2.path)); + } + async type(entry) { + if (entry._type === false) { + const map = await this.mapPromise; + const { type } = map.get(entry._fullpath); + entry._type = type; + } + return entry._type; + } + async mode(entry) { + if (entry._mode === false) { + const map = await this.mapPromise; + const { mode } = map.get(entry._fullpath); + entry._mode = normalizeMode(parseInt(mode, 8)); + } + return entry._mode; + } + async stat(_entry) { + } + async content(entry) { + if (entry._content === false) { + const map = await this.mapPromise; + const { fs, cache, gitdir } = this; + const obj = map.get(entry._fullpath); + const oid = obj.oid; + const { type, object } = await _readObject({ fs, cache, gitdir, oid }); + if (type !== "blob") { + entry._content = void 0; + } else { + entry._content = new Uint8Array(object); + } + } + return entry._content; + } + async oid(entry) { + if (entry._oid === false) { + const map = await this.mapPromise; + const obj = map.get(entry._fullpath); + entry._oid = obj.oid; + } + return entry._oid; + } +}; +function TREE({ ref = "HEAD" } = {}) { + const o = /* @__PURE__ */ Object.create(null); + Object.defineProperty(o, GitWalkSymbol, { + value: function({ fs, gitdir, cache }) { + return new GitWalkerRepo({ fs, gitdir, ref, cache }); + } + }); + Object.freeze(o); + return o; +} +var GitWalkerFs = class { + constructor({ fs, dir, gitdir, cache }) { + this.fs = fs; + this.cache = cache; + this.dir = dir; + this.gitdir = gitdir; + const walker = this; + this.ConstructEntry = class WorkdirEntry { + constructor(fullpath) { + this._fullpath = fullpath; + this._type = false; + this._mode = false; + this._stat = false; + this._content = false; + this._oid = false; + } + async type() { + return walker.type(this); + } + async mode() { + return walker.mode(this); + } + async stat() { + return walker.stat(this); + } + async content() { + return walker.content(this); + } + async oid() { + return walker.oid(this); + } + }; + } + async readdir(entry) { + const filepath = entry._fullpath; + const { fs, dir } = this; + const names = await fs.readdir(join(dir, filepath)); + if (names === null) + return null; + return names.map((name) => join(filepath, name)); + } + async type(entry) { + if (entry._type === false) { + await entry.stat(); + } + return entry._type; + } + async mode(entry) { + if (entry._mode === false) { + await entry.stat(); + } + return entry._mode; + } + async stat(entry) { + if (entry._stat === false) { + const { fs, dir } = this; + let stat = await fs.lstat(`${dir}/${entry._fullpath}`); + if (!stat) { + throw new Error( + `ENOENT: no such file or directory, lstat '${entry._fullpath}'` + ); + } + let type = stat.isDirectory() ? "tree" : "blob"; + if (type === "blob" && !stat.isFile() && !stat.isSymbolicLink()) { + type = "special"; + } + entry._type = type; + stat = normalizeStats(stat); + entry._mode = stat.mode; + if (stat.size === -1 && entry._actualSize) { + stat.size = entry._actualSize; + } + entry._stat = stat; + } + return entry._stat; + } + async content(entry) { + if (entry._content === false) { + const { fs, dir } = this; + if (await entry.type() === "tree") { + entry._content = void 0; + } else { + const content = await fs.read(`${dir}/${entry._fullpath}`); + entry._actualSize = content.length; + if (entry._stat && entry._stat.size === -1) { + entry._stat.size = entry._actualSize; + } + entry._content = new Uint8Array(content); + } + } + return entry._content; + } + async oid(entry) { + if (entry._oid === false) { + const { fs, gitdir, cache } = this; + let oid; + await GitIndexManager.acquire({ fs, gitdir, cache }, async function(index2) { + const stage = index2.entriesMap.get(entry._fullpath); + const stats = await entry.stat(); + if (!stage || compareStats(stats, stage)) { + const content = await entry.content(); + if (content === void 0) { + oid = void 0; + } else { + oid = await shasum( + GitObject.wrap({ type: "blob", object: await entry.content() }) + ); + if (stage && oid === stage.oid && stats.mode === stage.mode && compareStats(stats, stage)) { + index2.insert({ + filepath: entry._fullpath, + stats, + oid + }); + } + } + } else { + oid = stage.oid; + } + }); + entry._oid = oid; + } + return entry._oid; + } +}; +function WORKDIR() { + const o = /* @__PURE__ */ Object.create(null); + Object.defineProperty(o, GitWalkSymbol, { + value: function({ fs, dir, gitdir, cache }) { + return new GitWalkerFs({ fs, dir, gitdir, cache }); + } + }); + Object.freeze(o); + return o; +} +function arrayRange(start, end) { + const length = end - start; + return Array.from({ length }, (_, i) => start + i); +} +var flat = typeof Array.prototype.flat === "undefined" ? (entries) => entries.reduce((acc, x) => acc.concat(x), []) : (entries) => entries.flat(); +var RunningMinimum = class { + constructor() { + this.value = null; + } + consider(value) { + if (value === null || value === void 0) + return; + if (this.value === null) { + this.value = value; + } else if (value < this.value) { + this.value = value; + } + } + reset() { + this.value = null; + } +}; +function* unionOfIterators(sets) { + const min = new RunningMinimum(); + let minimum; + const heads = []; + const numsets = sets.length; + for (let i = 0; i < numsets; i++) { + heads[i] = sets[i].next().value; + if (heads[i] !== void 0) { + min.consider(heads[i]); + } + } + if (min.value === null) + return; + while (true) { + const result = []; + minimum = min.value; + min.reset(); + for (let i = 0; i < numsets; i++) { + if (heads[i] !== void 0 && heads[i] === minimum) { + result[i] = heads[i]; + heads[i] = sets[i].next().value; + } else { + result[i] = null; + } + if (heads[i] !== void 0) { + min.consider(heads[i]); + } + } + yield result; + if (min.value === null) + return; + } +} +async function _walk({ + fs, + cache, + dir, + gitdir, + trees, + // @ts-ignore + map = async (_, entry) => entry, + // The default reducer is a flatmap that filters out undefineds. + reduce = async (parent, children2) => { + const flatten = flat(children2); + if (parent !== void 0) + flatten.unshift(parent); + return flatten; + }, + // The default iterate function walks all children concurrently + iterate = (walk2, children2) => Promise.all([...children2].map(walk2)) +}) { + const walkers = trees.map( + (proxy) => proxy[GitWalkSymbol]({ fs, dir, gitdir, cache }) + ); + const root2 = new Array(walkers.length).fill("."); + const range = arrayRange(0, walkers.length); + const unionWalkerFromReaddir = async (entries) => { + range.map((i) => { + entries[i] = entries[i] && new walkers[i].ConstructEntry(entries[i]); + }); + const subdirs = await Promise.all( + range.map((i) => entries[i] ? walkers[i].readdir(entries[i]) : []) + ); + const iterators = subdirs.map((array) => array === null ? [] : array).map((array) => array[Symbol.iterator]()); + return { + entries, + children: unionOfIterators(iterators) + }; + }; + const walk2 = async (root3) => { + const { entries, children: children2 } = await unionWalkerFromReaddir(root3); + const fullpath = entries.find((entry) => entry && entry._fullpath)._fullpath; + const parent = await map(fullpath, entries); + if (parent !== null) { + let walkedChildren = await iterate(walk2, children2); + walkedChildren = walkedChildren.filter((x) => x !== void 0); + return reduce(parent, walkedChildren); + } + }; + return walk2(root2); +} +async function rmRecursive(fs, filepath) { + const entries = await fs.readdir(filepath); + if (entries == null) { + await fs.rm(filepath); + } else if (entries.length) { + await Promise.all( + entries.map((entry) => { + const subpath = join(filepath, entry); + return fs.lstat(subpath).then((stat) => { + if (!stat) + return; + return stat.isDirectory() ? rmRecursive(fs, subpath) : fs.rm(subpath); + }); + }) + ).then(() => fs.rmdir(filepath)); + } else { + await fs.rmdir(filepath); + } +} +function isPromiseFs(fs) { + const test = (targetFs) => { + try { + return targetFs.readFile().catch((e) => e); + } catch (e) { + return e; + } + }; + return test(fs).constructor.name === "Promise"; +} +var commands = [ + "readFile", + "writeFile", + "mkdir", + "rmdir", + "unlink", + "stat", + "lstat", + "readdir", + "readlink", + "symlink" +]; +function bindFs(target, fs) { + if (isPromiseFs(fs)) { + for (const command of commands) { + target[`_${command}`] = fs[command].bind(fs); + } + } else { + for (const command of commands) { + target[`_${command}`] = (0, import_pify.default)(fs[command].bind(fs)); + } + } + if (isPromiseFs(fs)) { + if (fs.rm) + target._rm = fs.rm.bind(fs); + else if (fs.rmdir.length > 1) + target._rm = fs.rmdir.bind(fs); + else + target._rm = rmRecursive.bind(null, target); + } else { + if (fs.rm) + target._rm = (0, import_pify.default)(fs.rm.bind(fs)); + else if (fs.rmdir.length > 2) + target._rm = (0, import_pify.default)(fs.rmdir.bind(fs)); + else + target._rm = rmRecursive.bind(null, target); + } +} +var FileSystem = class { + constructor(fs) { + if (typeof fs._original_unwrapped_fs !== "undefined") + return fs; + const promises = Object.getOwnPropertyDescriptor(fs, "promises"); + if (promises && promises.enumerable) { + bindFs(this, fs.promises); + } else { + bindFs(this, fs); + } + this._original_unwrapped_fs = fs; + } + /** + * Return true if a file exists, false if it doesn't exist. + * Rethrows errors that aren't related to file existance. + */ + async exists(filepath, options = {}) { + try { + await this._stat(filepath); + return true; + } catch (err) { + if (err.code === "ENOENT" || err.code === "ENOTDIR") { + return false; + } else { + console.log('Unhandled error in "FileSystem.exists()" function', err); + throw err; + } + } + } + /** + * Return the contents of a file if it exists, otherwise returns null. + * + * @param {string} filepath + * @param {object} [options] + * + * @returns {Promise} + */ + async read(filepath, options = {}) { + try { + let buffer2 = await this._readFile(filepath, options); + if (typeof buffer2 !== "string") { + buffer2 = Buffer.from(buffer2); + } + return buffer2; + } catch (err) { + return null; + } + } + /** + * Write a file (creating missing directories if need be) without throwing errors. + * + * @param {string} filepath + * @param {Buffer|Uint8Array|string} contents + * @param {object|string} [options] + */ + async write(filepath, contents, options = {}) { + try { + await this._writeFile(filepath, contents, options); + return; + } catch (err) { + await this.mkdir(dirname(filepath)); + await this._writeFile(filepath, contents, options); + } + } + /** + * Make a directory (or series of nested directories) without throwing an error if it already exists. + */ + async mkdir(filepath, _selfCall = false) { + try { + await this._mkdir(filepath); + return; + } catch (err) { + if (err === null) + return; + if (err.code === "EEXIST") + return; + if (_selfCall) + throw err; + if (err.code === "ENOENT") { + const parent = dirname(filepath); + if (parent === "." || parent === "/" || parent === filepath) + throw err; + await this.mkdir(parent); + await this.mkdir(filepath, true); + } + } + } + /** + * Delete a file without throwing an error if it is already deleted. + */ + async rm(filepath) { + try { + await this._unlink(filepath); + } catch (err) { + if (err.code !== "ENOENT") + throw err; + } + } + /** + * Delete a directory without throwing an error if it is already deleted. + */ + async rmdir(filepath, opts) { + try { + if (opts && opts.recursive) { + await this._rm(filepath, opts); + } else { + await this._rmdir(filepath); + } + } catch (err) { + if (err.code !== "ENOENT") + throw err; + } + } + /** + * Read a directory without throwing an error is the directory doesn't exist + */ + async readdir(filepath) { + try { + const names = await this._readdir(filepath); + names.sort(compareStrings); + return names; + } catch (err) { + if (err.code === "ENOTDIR") + return null; + return []; + } + } + /** + * Return a flast list of all the files nested inside a directory + * + * Based on an elegant concurrent recursive solution from SO + * https://stackoverflow.com/a/45130990/2168416 + */ + async readdirDeep(dir) { + const subdirs = await this._readdir(dir); + const files = await Promise.all( + subdirs.map(async (subdir) => { + const res = dir + "/" + subdir; + return (await this._stat(res)).isDirectory() ? this.readdirDeep(res) : res; + }) + ); + return files.reduce((a, f) => a.concat(f), []); + } + /** + * Return the Stats of a file/symlink if it exists, otherwise returns null. + * Rethrows errors that aren't related to file existance. + */ + async lstat(filename) { + try { + const stats = await this._lstat(filename); + return stats; + } catch (err) { + if (err.code === "ENOENT") { + return null; + } + throw err; + } + } + /** + * Reads the contents of a symlink if it exists, otherwise returns null. + * Rethrows errors that aren't related to file existance. + */ + async readlink(filename, opts = { encoding: "buffer" }) { + try { + const link = await this._readlink(filename, opts); + return Buffer.isBuffer(link) ? link : Buffer.from(link); + } catch (err) { + if (err.code === "ENOENT") { + return null; + } + throw err; + } + } + /** + * Write the contents of buffer to a symlink. + */ + async writelink(filename, buffer2) { + return this._symlink(buffer2.toString("utf8"), filename); + } +}; +function assertParameter(name, value) { + if (value === void 0) { + throw new MissingParameterError(name); + } +} +async function modified(entry, base) { + if (!entry && !base) + return false; + if (entry && !base) + return true; + if (!entry && base) + return true; + if (await entry.type() === "tree" && await base.type() === "tree") { + return false; + } + if (await entry.type() === await base.type() && await entry.mode() === await base.mode() && await entry.oid() === await base.oid()) { + return false; + } + return true; +} +async function abortMerge({ + fs: _fs, + dir, + gitdir = join(dir, ".git"), + commit: commit2 = "HEAD", + cache = {} +}) { + try { + assertParameter("fs", _fs); + assertParameter("dir", dir); + assertParameter("gitdir", gitdir); + const fs = new FileSystem(_fs); + const trees = [TREE({ ref: commit2 }), WORKDIR(), STAGE()]; + let unmergedPaths = []; + await GitIndexManager.acquire({ fs, gitdir, cache }, async function(index2) { + unmergedPaths = index2.unmergedPaths; + }); + const results = await _walk({ + fs, + cache, + dir, + gitdir, + trees, + map: async function(path2, [head, workdir, index2]) { + const staged = !await modified(workdir, index2); + const unmerged = unmergedPaths.includes(path2); + const unmodified = !await modified(index2, head); + if (staged || unmerged) { + return head ? { + path: path2, + mode: await head.mode(), + oid: await head.oid(), + type: await head.type(), + content: await head.content() + } : void 0; + } + if (unmodified) + return false; + else + throw new IndexResetError(path2); + } + }); + await GitIndexManager.acquire({ fs, gitdir, cache }, async function(index2) { + for (const entry of results) { + if (entry === false) + continue; + if (!entry) { + await fs.rmdir(`${dir}/${entry.path}`, { recursive: true }); + index2.delete({ filepath: entry.path }); + continue; + } + if (entry.type === "blob") { + const content = new TextDecoder().decode(entry.content); + await fs.write(`${dir}/${entry.path}`, content, { mode: entry.mode }); + index2.insert({ + filepath: entry.path, + oid: entry.oid, + stage: 0 + }); + } + } + }); + } catch (err) { + err.caller = "git.abortMerge"; + throw err; + } +} +var GitIgnoreManager = class { + static async isIgnored({ fs, dir, gitdir = join(dir, ".git"), filepath }) { + if (basename(filepath) === ".git") + return true; + if (filepath === ".") + return false; + let excludes = ""; + const excludesFile = join(gitdir, "info", "exclude"); + if (await fs.exists(excludesFile)) { + excludes = await fs.read(excludesFile, "utf8"); + } + const pairs = [ + { + gitignore: join(dir, ".gitignore"), + filepath + } + ]; + const pieces = filepath.split("/").filter(Boolean); + for (let i = 1; i < pieces.length; i++) { + const folder = pieces.slice(0, i).join("/"); + const file = pieces.slice(i).join("/"); + pairs.push({ + gitignore: join(dir, folder, ".gitignore"), + filepath: file + }); + } + let ignoredStatus = false; + for (const p of pairs) { + let file; + try { + file = await fs.read(p.gitignore, "utf8"); + } catch (err) { + if (err.code === "NOENT") + continue; + } + const ign = (0, import_ignore.default)().add(excludes); + ign.add(file); + const parentdir = dirname(p.filepath); + if (parentdir !== "." && ign.ignores(parentdir)) + return true; + if (ignoredStatus) { + ignoredStatus = !ign.test(p.filepath).unignored; + } else { + ignoredStatus = ign.test(p.filepath).ignored; + } + } + return ignoredStatus; + } +}; +async function writeObjectLoose({ fs, gitdir, object, format, oid }) { + if (format !== "deflated") { + throw new InternalError( + "GitObjectStoreLoose expects objects to write to be in deflated format" + ); + } + const source = `objects/${oid.slice(0, 2)}/${oid.slice(2)}`; + const filepath = `${gitdir}/${source}`; + if (!await fs.exists(filepath)) + await fs.write(filepath, object); +} +var supportsCompressionStream = null; +async function deflate(buffer2) { + if (supportsCompressionStream === null) { + supportsCompressionStream = testCompressionStream(); + } + return supportsCompressionStream ? browserDeflate(buffer2) : import_pako.default.deflate(buffer2); +} +async function browserDeflate(buffer2) { + const cs = new CompressionStream("deflate"); + const c = new Blob([buffer2]).stream().pipeThrough(cs); + return new Uint8Array(await new Response(c).arrayBuffer()); +} +function testCompressionStream() { + try { + const cs = new CompressionStream("deflate"); + new Blob([]).stream(); + if (cs) + return true; + } catch (_) { + } + return false; +} +async function _writeObject({ + fs, + gitdir, + type, + object, + format = "content", + oid = void 0, + dryRun = false +}) { + if (format !== "deflated") { + if (format !== "wrapped") { + object = GitObject.wrap({ type, object }); + } + oid = await shasum(object); + object = Buffer.from(await deflate(object)); + } + if (!dryRun) { + await writeObjectLoose({ fs, gitdir, object, format: "deflated", oid }); + } + return oid; +} +function posixifyPathBuffer(buffer2) { + let idx; + while (~(idx = buffer2.indexOf(92))) + buffer2[idx] = 47; + return buffer2; +} +async function add({ + fs: _fs, + dir, + gitdir = join(dir, ".git"), + filepath, + cache = {}, + force = false, + parallel = true +}) { + try { + assertParameter("fs", _fs); + assertParameter("dir", dir); + assertParameter("gitdir", gitdir); + assertParameter("filepath", filepath); + const fs = new FileSystem(_fs); + await GitIndexManager.acquire({ fs, gitdir, cache }, async (index2) => { + return addToIndex({ + dir, + gitdir, + fs, + filepath, + index: index2, + force, + parallel + }); + }); + } catch (err) { + err.caller = "git.add"; + throw err; + } +} +async function addToIndex({ + dir, + gitdir, + fs, + filepath, + index: index2, + force, + parallel +}) { + filepath = Array.isArray(filepath) ? filepath : [filepath]; + const promises = filepath.map(async (currentFilepath) => { + if (!force) { + const ignored = await GitIgnoreManager.isIgnored({ + fs, + dir, + gitdir, + filepath: currentFilepath + }); + if (ignored) + return; + } + const stats = await fs.lstat(join(dir, currentFilepath)); + if (!stats) + throw new NotFoundError(currentFilepath); + if (stats.isDirectory()) { + const children2 = await fs.readdir(join(dir, currentFilepath)); + if (parallel) { + const promises2 = children2.map( + (child) => addToIndex({ + dir, + gitdir, + fs, + filepath: [join(currentFilepath, child)], + index: index2, + force, + parallel + }) + ); + await Promise.all(promises2); + } else { + for (const child of children2) { + await addToIndex({ + dir, + gitdir, + fs, + filepath: [join(currentFilepath, child)], + index: index2, + force, + parallel + }); + } + } + } else { + const object = stats.isSymbolicLink() ? await fs.readlink(join(dir, currentFilepath)).then(posixifyPathBuffer) : await fs.read(join(dir, currentFilepath)); + if (object === null) + throw new NotFoundError(currentFilepath); + const oid = await _writeObject({ fs, gitdir, type: "blob", object }); + index2.insert({ filepath: currentFilepath, stats, oid }); + } + }); + const settledPromises = await Promise.allSettled(promises); + const rejectedPromises = settledPromises.filter((settle) => settle.status === "rejected").map((settle) => settle.reason); + if (rejectedPromises.length > 1) { + throw new MultipleGitError(rejectedPromises); + } + if (rejectedPromises.length === 1) { + throw rejectedPromises[0]; + } + const fulfilledPromises = settledPromises.filter((settle) => settle.status === "fulfilled" && settle.value).map((settle) => settle.value); + return fulfilledPromises; +} +async function _commit({ + fs, + cache, + onSign, + gitdir, + message, + author, + committer, + signingKey, + dryRun = false, + noUpdateBranch = false, + ref, + parent, + tree +}) { + if (!ref) { + ref = await GitRefManager.resolve({ + fs, + gitdir, + ref: "HEAD", + depth: 2 + }); + } + return GitIndexManager.acquire( + { fs, gitdir, cache, allowUnmerged: false }, + async function(index2) { + const inodes = flatFileListToDirectoryStructure(index2.entries); + const inode = inodes.get("."); + if (!tree) { + tree = await constructTree({ fs, gitdir, inode, dryRun }); + } + if (!parent) { + try { + parent = [ + await GitRefManager.resolve({ + fs, + gitdir, + ref + }) + ]; + } catch (err) { + parent = []; + } + } else { + parent = await Promise.all( + parent.map((p) => { + return GitRefManager.resolve({ fs, gitdir, ref: p }); + }) + ); + } + let comm = GitCommit.from({ + tree, + parent, + author, + committer, + message + }); + if (signingKey) { + comm = await GitCommit.sign(comm, onSign, signingKey); + } + const oid = await _writeObject({ + fs, + gitdir, + type: "commit", + object: comm.toObject(), + dryRun + }); + if (!noUpdateBranch && !dryRun) { + await GitRefManager.writeRef({ + fs, + gitdir, + ref, + value: oid + }); + } + return oid; + } + ); +} +async function constructTree({ fs, gitdir, inode, dryRun }) { + const children2 = inode.children; + for (const inode2 of children2) { + if (inode2.type === "tree") { + inode2.metadata.mode = "040000"; + inode2.metadata.oid = await constructTree({ fs, gitdir, inode: inode2, dryRun }); + } + } + const entries = children2.map((inode2) => ({ + mode: inode2.metadata.mode, + path: inode2.basename, + oid: inode2.metadata.oid, + type: inode2.type + })); + const tree = GitTree.from(entries); + const oid = await _writeObject({ + fs, + gitdir, + type: "tree", + object: tree.toObject(), + dryRun + }); + return oid; +} +async function resolveFilepath({ fs, cache, gitdir, oid, filepath }) { + if (filepath.startsWith("/")) { + throw new InvalidFilepathError("leading-slash"); + } else if (filepath.endsWith("/")) { + throw new InvalidFilepathError("trailing-slash"); + } + const _oid = oid; + const result = await resolveTree({ fs, cache, gitdir, oid }); + const tree = result.tree; + if (filepath === "") { + oid = result.oid; + } else { + const pathArray = filepath.split("/"); + oid = await _resolveFilepath({ + fs, + cache, + gitdir, + tree, + pathArray, + oid: _oid, + filepath + }); + } + return oid; +} +async function _resolveFilepath({ + fs, + cache, + gitdir, + tree, + pathArray, + oid, + filepath +}) { + const name = pathArray.shift(); + for (const entry of tree) { + if (entry.path === name) { + if (pathArray.length === 0) { + return entry.oid; + } else { + const { type, object } = await _readObject({ + fs, + cache, + gitdir, + oid: entry.oid + }); + if (type !== "tree") { + throw new ObjectTypeError(oid, type, "tree", filepath); + } + tree = GitTree.from(object); + return _resolveFilepath({ + fs, + cache, + gitdir, + tree, + pathArray, + oid, + filepath + }); + } + } + } + throw new NotFoundError(`file or directory found at "${oid}:${filepath}"`); +} +async function _readTree({ + fs, + cache, + gitdir, + oid, + filepath = void 0 +}) { + if (filepath !== void 0) { + oid = await resolveFilepath({ fs, cache, gitdir, oid, filepath }); + } + const { tree, oid: treeOid } = await resolveTree({ fs, cache, gitdir, oid }); + const result = { + oid: treeOid, + tree: tree.entries() + }; + return result; +} +async function _writeTree({ fs, gitdir, tree }) { + const object = GitTree.from(tree).toObject(); + const oid = await _writeObject({ + fs, + gitdir, + type: "tree", + object, + format: "content" + }); + return oid; +} +async function _addNote({ + fs, + cache, + onSign, + gitdir, + ref, + oid, + note, + force, + author, + committer, + signingKey +}) { + let parent; + try { + parent = await GitRefManager.resolve({ gitdir, fs, ref }); + } catch (err) { + if (!(err instanceof NotFoundError)) { + throw err; + } + } + const result = await _readTree({ + fs, + cache, + gitdir, + oid: parent || "4b825dc642cb6eb9a060e54bf8d69288fbee4904" + }); + let tree = result.tree; + if (force) { + tree = tree.filter((entry) => entry.path !== oid); + } else { + for (const entry of tree) { + if (entry.path === oid) { + throw new AlreadyExistsError("note", oid); + } + } + } + if (typeof note === "string") { + note = Buffer.from(note, "utf8"); + } + const noteOid = await _writeObject({ + fs, + gitdir, + type: "blob", + object: note, + format: "content" + }); + tree.push({ mode: "100644", path: oid, oid: noteOid, type: "blob" }); + const treeOid = await _writeTree({ + fs, + gitdir, + tree + }); + const commitOid = await _commit({ + fs, + cache, + onSign, + gitdir, + ref, + tree: treeOid, + parent: parent && [parent], + message: `Note added by 'isomorphic-git addNote' +`, + author, + committer, + signingKey + }); + return commitOid; +} +async function _getConfig({ fs, gitdir, path: path2 }) { + const config = await GitConfigManager.get({ fs, gitdir }); + return config.get(path2); +} +async function normalizeAuthorObject({ fs, gitdir, author = {} }) { + let { name, email, timestamp, timezoneOffset } = author; + name = name || await _getConfig({ fs, gitdir, path: "user.name" }); + email = email || await _getConfig({ fs, gitdir, path: "user.email" }) || ""; + if (name === void 0) { + return void 0; + } + timestamp = timestamp != null ? timestamp : Math.floor(Date.now() / 1e3); + timezoneOffset = timezoneOffset != null ? timezoneOffset : new Date(timestamp * 1e3).getTimezoneOffset(); + return { name, email, timestamp, timezoneOffset }; +} +async function normalizeCommitterObject({ + fs, + gitdir, + author, + committer +}) { + committer = Object.assign({}, committer || author); + if (author) { + committer.timestamp = committer.timestamp || author.timestamp; + committer.timezoneOffset = committer.timezoneOffset || author.timezoneOffset; + } + committer = await normalizeAuthorObject({ fs, gitdir, author: committer }); + return committer; +} +async function addNote({ + fs: _fs, + onSign, + dir, + gitdir = join(dir, ".git"), + ref = "refs/notes/commits", + oid, + note, + force, + author: _author, + committer: _committer, + signingKey, + cache = {} +}) { + try { + assertParameter("fs", _fs); + assertParameter("gitdir", gitdir); + assertParameter("oid", oid); + assertParameter("note", note); + if (signingKey) { + assertParameter("onSign", onSign); + } + const fs = new FileSystem(_fs); + const author = await normalizeAuthorObject({ fs, gitdir, author: _author }); + if (!author) + throw new MissingNameError("author"); + const committer = await normalizeCommitterObject({ + fs, + gitdir, + author, + committer: _committer + }); + if (!committer) + throw new MissingNameError("committer"); + return await _addNote({ + fs: new FileSystem(fs), + cache, + onSign, + gitdir, + ref, + oid, + note, + force, + author, + committer, + signingKey + }); + } catch (err) { + err.caller = "git.addNote"; + throw err; + } +} +async function _addRemote({ fs, gitdir, remote, url, force }) { + if (remote !== import_clean_git_ref.default.clean(remote)) { + throw new InvalidRefNameError(remote, import_clean_git_ref.default.clean(remote)); + } + const config = await GitConfigManager.get({ fs, gitdir }); + if (!force) { + const remoteNames = await config.getSubsections("remote"); + if (remoteNames.includes(remote)) { + if (url !== await config.get(`remote.${remote}.url`)) { + throw new AlreadyExistsError("remote", remote); + } + } + } + await config.set(`remote.${remote}.url`, url); + await config.set( + `remote.${remote}.fetch`, + `+refs/heads/*:refs/remotes/${remote}/*` + ); + await GitConfigManager.save({ fs, gitdir, config }); +} +async function addRemote({ + fs, + dir, + gitdir = join(dir, ".git"), + remote, + url, + force = false +}) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + assertParameter("remote", remote); + assertParameter("url", url); + return await _addRemote({ + fs: new FileSystem(fs), + gitdir, + remote, + url, + force + }); + } catch (err) { + err.caller = "git.addRemote"; + throw err; + } +} +async function _annotatedTag({ + fs, + cache, + onSign, + gitdir, + ref, + tagger, + message = ref, + gpgsig, + object, + signingKey, + force = false +}) { + ref = ref.startsWith("refs/tags/") ? ref : `refs/tags/${ref}`; + if (!force && await GitRefManager.exists({ fs, gitdir, ref })) { + throw new AlreadyExistsError("tag", ref); + } + const oid = await GitRefManager.resolve({ + fs, + gitdir, + ref: object || "HEAD" + }); + const { type } = await _readObject({ fs, cache, gitdir, oid }); + let tagObject = GitAnnotatedTag.from({ + object: oid, + type, + tag: ref.replace("refs/tags/", ""), + tagger, + message, + gpgsig + }); + if (signingKey) { + tagObject = await GitAnnotatedTag.sign(tagObject, onSign, signingKey); + } + const value = await _writeObject({ + fs, + gitdir, + type: "tag", + object: tagObject.toObject() + }); + await GitRefManager.writeRef({ fs, gitdir, ref, value }); +} +async function annotatedTag({ + fs: _fs, + onSign, + dir, + gitdir = join(dir, ".git"), + ref, + tagger: _tagger, + message = ref, + gpgsig, + object, + signingKey, + force = false, + cache = {} +}) { + try { + assertParameter("fs", _fs); + assertParameter("gitdir", gitdir); + assertParameter("ref", ref); + if (signingKey) { + assertParameter("onSign", onSign); + } + const fs = new FileSystem(_fs); + const tagger = await normalizeAuthorObject({ fs, gitdir, author: _tagger }); + if (!tagger) + throw new MissingNameError("tagger"); + return await _annotatedTag({ + fs, + cache, + onSign, + gitdir, + ref, + tagger, + message, + gpgsig, + object, + signingKey, + force + }); + } catch (err) { + err.caller = "git.annotatedTag"; + throw err; + } +} +async function _branch({ + fs, + gitdir, + ref, + object, + checkout: checkout2 = false, + force = false +}) { + if (ref !== import_clean_git_ref.default.clean(ref)) { + throw new InvalidRefNameError(ref, import_clean_git_ref.default.clean(ref)); + } + const fullref = `refs/heads/${ref}`; + if (!force) { + const exist = await GitRefManager.exists({ fs, gitdir, ref: fullref }); + if (exist) { + throw new AlreadyExistsError("branch", ref, false); + } + } + let oid; + try { + oid = await GitRefManager.resolve({ fs, gitdir, ref: object || "HEAD" }); + } catch (e) { + } + if (oid) { + await GitRefManager.writeRef({ fs, gitdir, ref: fullref, value: oid }); + } + if (checkout2) { + await GitRefManager.writeSymbolicRef({ + fs, + gitdir, + ref: "HEAD", + value: fullref + }); + } +} +async function branch({ + fs, + dir, + gitdir = join(dir, ".git"), + ref, + object, + checkout: checkout2 = false, + force = false +}) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + assertParameter("ref", ref); + return await _branch({ + fs: new FileSystem(fs), + gitdir, + ref, + object, + checkout: checkout2, + force + }); + } catch (err) { + err.caller = "git.branch"; + throw err; + } +} +var worthWalking = (filepath, root2) => { + if (filepath === "." || root2 == null || root2.length === 0 || root2 === ".") { + return true; + } + if (root2.length >= filepath.length) { + return root2.startsWith(filepath); + } else { + return filepath.startsWith(root2); + } +}; +async function _checkout({ + fs, + cache, + onProgress, + dir, + gitdir, + remote, + ref, + filepaths, + noCheckout, + noUpdateHead, + dryRun, + force, + track = true +}) { + let oid; + try { + oid = await GitRefManager.resolve({ fs, gitdir, ref }); + } catch (err) { + if (ref === "HEAD") + throw err; + const remoteRef = `${remote}/${ref}`; + oid = await GitRefManager.resolve({ + fs, + gitdir, + ref: remoteRef + }); + if (track) { + const config = await GitConfigManager.get({ fs, gitdir }); + await config.set(`branch.${ref}.remote`, remote); + await config.set(`branch.${ref}.merge`, `refs/heads/${ref}`); + await GitConfigManager.save({ fs, gitdir, config }); + } + await GitRefManager.writeRef({ + fs, + gitdir, + ref: `refs/heads/${ref}`, + value: oid + }); + } + if (!noCheckout) { + let ops; + try { + ops = await analyze({ + fs, + cache, + onProgress, + dir, + gitdir, + ref, + force, + filepaths + }); + } catch (err) { + if (err instanceof NotFoundError && err.data.what === oid) { + throw new CommitNotFetchedError(ref, oid); + } else { + throw err; + } + } + const conflicts2 = ops.filter(([method2]) => method2 === "conflict").map(([method2, fullpath]) => fullpath); + if (conflicts2.length > 0) { + throw new CheckoutConflictError(conflicts2); + } + const errors = ops.filter(([method2]) => method2 === "error").map(([method2, fullpath]) => fullpath); + if (errors.length > 0) { + throw new InternalError(errors.join(", ")); + } + if (dryRun) { + return; + } + let count = 0; + const total = ops.length; + await GitIndexManager.acquire({ fs, gitdir, cache }, async function(index2) { + await Promise.all( + ops.filter( + ([method2]) => method2 === "delete" || method2 === "delete-index" + ).map(async function([method2, fullpath]) { + const filepath = `${dir}/${fullpath}`; + if (method2 === "delete") { + await fs.rm(filepath); + } + index2.delete({ filepath: fullpath }); + if (onProgress) { + await onProgress({ + phase: "Updating workdir", + loaded: ++count, + total + }); + } + }) + ); + }); + await GitIndexManager.acquire({ fs, gitdir, cache }, async function(index2) { + for (const [method2, fullpath] of ops) { + if (method2 === "rmdir" || method2 === "rmdir-index") { + const filepath = `${dir}/${fullpath}`; + try { + if (method2 === "rmdir-index") { + index2.delete({ filepath: fullpath }); + } + await fs.rmdir(filepath); + if (onProgress) { + await onProgress({ + phase: "Updating workdir", + loaded: ++count, + total + }); + } + } catch (e) { + if (e.code === "ENOTEMPTY") { + console.log( + `Did not delete ${fullpath} because directory is not empty` + ); + } else { + throw e; + } + } + } + } + }); + await Promise.all( + ops.filter(([method2]) => method2 === "mkdir" || method2 === "mkdir-index").map(async function([_, fullpath]) { + const filepath = `${dir}/${fullpath}`; + await fs.mkdir(filepath); + if (onProgress) { + await onProgress({ + phase: "Updating workdir", + loaded: ++count, + total + }); + } + }) + ); + await GitIndexManager.acquire({ fs, gitdir, cache }, async function(index2) { + await Promise.all( + ops.filter( + ([method2]) => method2 === "create" || method2 === "create-index" || method2 === "update" || method2 === "mkdir-index" + ).map(async function([method2, fullpath, oid2, mode, chmod]) { + const filepath = `${dir}/${fullpath}`; + try { + if (method2 !== "create-index" && method2 !== "mkdir-index") { + const { object } = await _readObject({ fs, cache, gitdir, oid: oid2 }); + if (chmod) { + await fs.rm(filepath); + } + if (mode === 33188) { + await fs.write(filepath, object); + } else if (mode === 33261) { + await fs.write(filepath, object, { mode: 511 }); + } else if (mode === 40960) { + await fs.writelink(filepath, object); + } else { + throw new InternalError( + `Invalid mode 0o${mode.toString(8)} detected in blob ${oid2}` + ); + } + } + const stats = await fs.lstat(filepath); + if (mode === 33261) { + stats.mode = 493; + } + if (method2 === "mkdir-index") { + stats.mode = 57344; + } + index2.insert({ + filepath: fullpath, + stats, + oid: oid2 + }); + if (onProgress) { + await onProgress({ + phase: "Updating workdir", + loaded: ++count, + total + }); + } + } catch (e) { + console.log(e); + } + }) + ); + }); + } + if (!noUpdateHead) { + const fullRef = await GitRefManager.expand({ fs, gitdir, ref }); + if (fullRef.startsWith("refs/heads")) { + await GitRefManager.writeSymbolicRef({ + fs, + gitdir, + ref: "HEAD", + value: fullRef + }); + } else { + await GitRefManager.writeRef({ fs, gitdir, ref: "HEAD", value: oid }); + } + } +} +async function analyze({ + fs, + cache, + onProgress, + dir, + gitdir, + ref, + force, + filepaths +}) { + let count = 0; + return _walk({ + fs, + cache, + dir, + gitdir, + trees: [TREE({ ref }), WORKDIR(), STAGE()], + map: async function(fullpath, [commit2, workdir, stage]) { + if (fullpath === ".") + return; + if (filepaths && !filepaths.some((base) => worthWalking(fullpath, base))) { + return null; + } + if (onProgress) { + await onProgress({ phase: "Analyzing workdir", loaded: ++count }); + } + const key2 = [!!stage, !!commit2, !!workdir].map(Number).join(""); + switch (key2) { + case "000": + return; + case "001": + if (force && filepaths && filepaths.includes(fullpath)) { + return ["delete", fullpath]; + } + return; + case "010": { + switch (await commit2.type()) { + case "tree": { + return ["mkdir", fullpath]; + } + case "blob": { + return [ + "create", + fullpath, + await commit2.oid(), + await commit2.mode() + ]; + } + case "commit": { + return [ + "mkdir-index", + fullpath, + await commit2.oid(), + await commit2.mode() + ]; + } + default: { + return [ + "error", + `new entry Unhandled type ${await commit2.type()}` + ]; + } + } + } + case "011": { + switch (`${await commit2.type()}-${await workdir.type()}`) { + case "tree-tree": { + return; + } + case "tree-blob": + case "blob-tree": { + return ["conflict", fullpath]; + } + case "blob-blob": { + if (await commit2.oid() !== await workdir.oid()) { + if (force) { + return [ + "update", + fullpath, + await commit2.oid(), + await commit2.mode(), + await commit2.mode() !== await workdir.mode() + ]; + } else { + return ["conflict", fullpath]; + } + } else { + if (await commit2.mode() !== await workdir.mode()) { + if (force) { + return [ + "update", + fullpath, + await commit2.oid(), + await commit2.mode(), + true + ]; + } else { + return ["conflict", fullpath]; + } + } else { + return [ + "create-index", + fullpath, + await commit2.oid(), + await commit2.mode() + ]; + } + } + } + case "commit-tree": { + return; + } + case "commit-blob": { + return ["conflict", fullpath]; + } + default: { + return ["error", `new entry Unhandled type ${commit2.type}`]; + } + } + } + case "100": { + return ["delete-index", fullpath]; + } + case "101": { + switch (await stage.type()) { + case "tree": { + return ["rmdir", fullpath]; + } + case "blob": { + if (await stage.oid() !== await workdir.oid()) { + if (force) { + return ["delete", fullpath]; + } else { + return ["conflict", fullpath]; + } + } else { + return ["delete", fullpath]; + } + } + case "commit": { + return ["rmdir-index", fullpath]; + } + default: { + return [ + "error", + `delete entry Unhandled type ${await stage.type()}` + ]; + } + } + } + case "110": + case "111": { + switch (`${await stage.type()}-${await commit2.type()}`) { + case "tree-tree": { + return; + } + case "blob-blob": { + if (await stage.oid() === await commit2.oid() && await stage.mode() === await commit2.mode() && !force) { + return; + } + if (workdir) { + if (await workdir.oid() !== await stage.oid() && await workdir.oid() !== await commit2.oid()) { + if (force) { + return [ + "update", + fullpath, + await commit2.oid(), + await commit2.mode(), + await commit2.mode() !== await workdir.mode() + ]; + } else { + return ["conflict", fullpath]; + } + } + } else if (force) { + return [ + "update", + fullpath, + await commit2.oid(), + await commit2.mode(), + await commit2.mode() !== await stage.mode() + ]; + } + if (await commit2.mode() !== await stage.mode()) { + return [ + "update", + fullpath, + await commit2.oid(), + await commit2.mode(), + true + ]; + } + if (await commit2.oid() !== await stage.oid()) { + return [ + "update", + fullpath, + await commit2.oid(), + await commit2.mode(), + false + ]; + } else { + return; + } + } + case "tree-blob": { + return ["update-dir-to-blob", fullpath, await commit2.oid()]; + } + case "blob-tree": { + return ["update-blob-to-tree", fullpath]; + } + case "commit-commit": { + return [ + "mkdir-index", + fullpath, + await commit2.oid(), + await commit2.mode() + ]; + } + default: { + return [ + "error", + `update entry Unhandled type ${await stage.type()}-${await commit2.type()}` + ]; + } + } + } + } + }, + // Modify the default flat mapping + reduce: async function(parent, children2) { + children2 = flat(children2); + if (!parent) { + return children2; + } else if (parent && parent[0] === "rmdir") { + children2.push(parent); + return children2; + } else { + children2.unshift(parent); + return children2; + } + } + }); +} +async function checkout({ + fs, + onProgress, + dir, + gitdir = join(dir, ".git"), + remote = "origin", + ref: _ref, + filepaths, + noCheckout = false, + noUpdateHead = _ref === void 0, + dryRun = false, + force = false, + track = true, + cache = {} +}) { + try { + assertParameter("fs", fs); + assertParameter("dir", dir); + assertParameter("gitdir", gitdir); + const ref = _ref || "HEAD"; + return await _checkout({ + fs: new FileSystem(fs), + cache, + onProgress, + dir, + gitdir, + remote, + ref, + filepaths, + noCheckout, + noUpdateHead, + dryRun, + force, + track + }); + } catch (err) { + err.caller = "git.checkout"; + throw err; + } +} +var abbreviateRx = new RegExp("^refs/(heads/|tags/|remotes/)?(.*)"); +function abbreviateRef(ref) { + const match = abbreviateRx.exec(ref); + if (match) { + if (match[1] === "remotes/" && ref.endsWith("/HEAD")) { + return match[2].slice(0, -5); + } else { + return match[2]; + } + } + return ref; +} +async function _currentBranch({ + fs, + gitdir, + fullname = false, + test = false +}) { + const ref = await GitRefManager.resolve({ + fs, + gitdir, + ref: "HEAD", + depth: 2 + }); + if (test) { + try { + await GitRefManager.resolve({ fs, gitdir, ref }); + } catch (_) { + return; + } + } + if (!ref.startsWith("refs/")) + return; + return fullname ? ref : abbreviateRef(ref); +} +function translateSSHtoHTTP(url) { + url = url.replace(/^git@([^:]+):/, "https://$1/"); + url = url.replace(/^ssh:\/\//, "https://"); + return url; +} +function calculateBasicAuthHeader({ username = "", password = "" }) { + return `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`; +} +async function forAwait(iterable, cb) { + const iter = getIterator(iterable); + while (true) { + const { value, done } = await iter.next(); + if (value) + await cb(value); + if (done) + break; + } + if (iter.return) + iter.return(); +} +async function collect(iterable) { + let size = 0; + const buffers = []; + await forAwait(iterable, (value) => { + buffers.push(value); + size += value.byteLength; + }); + const result = new Uint8Array(size); + let nextIndex = 0; + for (const buffer2 of buffers) { + result.set(buffer2, nextIndex); + nextIndex += buffer2.byteLength; + } + return result; +} +function extractAuthFromUrl(url) { + let userpass = url.match(/^https?:\/\/([^/]+)@/); + if (userpass == null) + return { url, auth: {} }; + userpass = userpass[1]; + const [username, password] = userpass.split(":"); + url = url.replace(`${userpass}@`, ""); + return { url, auth: { username, password } }; +} +function padHex(b, n) { + const s = n.toString(16); + return "0".repeat(b - s.length) + s; +} +var GitPktLine = class { + static flush() { + return Buffer.from("0000", "utf8"); + } + static delim() { + return Buffer.from("0001", "utf8"); + } + static encode(line) { + if (typeof line === "string") { + line = Buffer.from(line); + } + const length = line.length + 4; + const hexlength = padHex(4, length); + return Buffer.concat([Buffer.from(hexlength, "utf8"), line]); + } + static streamReader(stream) { + const reader = new StreamReader(stream); + return async function read() { + try { + let length = await reader.read(4); + if (length == null) + return true; + length = parseInt(length.toString("utf8"), 16); + if (length === 0) + return null; + if (length === 1) + return null; + const buffer2 = await reader.read(length - 4); + if (buffer2 == null) + return true; + return buffer2; + } catch (err) { + console.log("error", err); + return true; + } + }; + } +}; +async function parseCapabilitiesV2(read) { + const capabilities2 = {}; + let line; + while (true) { + line = await read(); + if (line === true) + break; + if (line === null) + continue; + line = line.toString("utf8").replace(/\n$/, ""); + const i = line.indexOf("="); + if (i > -1) { + const key2 = line.slice(0, i); + const value = line.slice(i + 1); + capabilities2[key2] = value; + } else { + capabilities2[line] = true; + } + } + return { protocolVersion: 2, capabilities2 }; +} +async function parseRefsAdResponse(stream, { service }) { + const capabilities = /* @__PURE__ */ new Set(); + const refs = /* @__PURE__ */ new Map(); + const symrefs = /* @__PURE__ */ new Map(); + const read = GitPktLine.streamReader(stream); + let lineOne = await read(); + while (lineOne === null) + lineOne = await read(); + if (lineOne === true) + throw new EmptyServerResponseError(); + if (lineOne.includes("version 2")) { + return parseCapabilitiesV2(read); + } + if (lineOne.toString("utf8").replace(/\n$/, "") !== `# service=${service}`) { + throw new ParseError(`# service=${service}\\n`, lineOne.toString("utf8")); + } + let lineTwo = await read(); + while (lineTwo === null) + lineTwo = await read(); + if (lineTwo === true) + return { capabilities, refs, symrefs }; + lineTwo = lineTwo.toString("utf8"); + if (lineTwo.includes("version 2")) { + return parseCapabilitiesV2(read); + } + const [firstRef, capabilitiesLine] = splitAndAssert(lineTwo, "\0", "\\x00"); + capabilitiesLine.split(" ").map((x) => capabilities.add(x)); + const [ref, name] = splitAndAssert(firstRef, " ", " "); + refs.set(name, ref); + while (true) { + const line = await read(); + if (line === true) + break; + if (line !== null) { + const [ref2, name2] = splitAndAssert(line.toString("utf8"), " ", " "); + refs.set(name2, ref2); + } + } + for (const cap of capabilities) { + if (cap.startsWith("symref=")) { + const m = cap.match(/symref=([^:]+):(.*)/); + if (m.length === 3) { + symrefs.set(m[1], m[2]); + } + } + } + return { protocolVersion: 1, capabilities, refs, symrefs }; +} +function splitAndAssert(line, sep2, expected) { + const split = line.trim().split(sep2); + if (split.length !== 2) { + throw new ParseError( + `Two strings separated by '${expected}'`, + line.toString("utf8") + ); + } + return split; +} +var corsProxify = (corsProxy, url) => corsProxy.endsWith("?") ? `${corsProxy}${url}` : `${corsProxy}/${url.replace(/^https?:\/\//, "")}`; +var updateHeaders = (headers, auth) => { + if (auth.username || auth.password) { + headers.Authorization = calculateBasicAuthHeader(auth); + } + if (auth.headers) { + Object.assign(headers, auth.headers); + } +}; +var stringifyBody = async (res) => { + try { + const data = Buffer.from(await collect(res.body)); + const response = data.toString("utf8"); + const preview = response.length < 256 ? response : response.slice(0, 256) + "..."; + return { preview, response, data }; + } catch (e) { + return {}; + } +}; +var GitRemoteHTTP = class { + static async capabilities() { + return ["discover", "connect"]; + } + /** + * @param {Object} args + * @param {HttpClient} args.http + * @param {ProgressCallback} [args.onProgress] + * @param {AuthCallback} [args.onAuth] + * @param {AuthFailureCallback} [args.onAuthFailure] + * @param {AuthSuccessCallback} [args.onAuthSuccess] + * @param {string} [args.corsProxy] + * @param {string} args.service + * @param {string} args.url + * @param {Object} args.headers + * @param {1 | 2} args.protocolVersion - Git Protocol Version + */ + static async discover({ + http, + onProgress, + onAuth, + onAuthSuccess, + onAuthFailure, + corsProxy, + service, + url: _origUrl, + headers, + protocolVersion + }) { + let { url, auth } = extractAuthFromUrl(_origUrl); + const proxifiedURL = corsProxy ? corsProxify(corsProxy, url) : url; + if (auth.username || auth.password) { + headers.Authorization = calculateBasicAuthHeader(auth); + } + if (protocolVersion === 2) { + headers["Git-Protocol"] = "version=2"; + } + let res; + let tryAgain; + let providedAuthBefore = false; + do { + res = await http.request({ + onProgress, + method: "GET", + url: `${proxifiedURL}/info/refs?service=${service}`, + headers + }); + tryAgain = false; + if (res.statusCode === 401 || res.statusCode === 203) { + const getAuth = providedAuthBefore ? onAuthFailure : onAuth; + if (getAuth) { + auth = await getAuth(url, { + ...auth, + headers: { ...headers } + }); + if (auth && auth.cancel) { + throw new UserCanceledError(); + } else if (auth) { + updateHeaders(headers, auth); + providedAuthBefore = true; + tryAgain = true; + } + } + } else if (res.statusCode === 200 && providedAuthBefore && onAuthSuccess) { + await onAuthSuccess(url, auth); + } + } while (tryAgain); + if (res.statusCode !== 200) { + const { response } = await stringifyBody(res); + throw new HttpError(res.statusCode, res.statusMessage, response); + } + if (res.headers["content-type"] === `application/x-${service}-advertisement`) { + const remoteHTTP = await parseRefsAdResponse(res.body, { service }); + remoteHTTP.auth = auth; + return remoteHTTP; + } else { + const { preview, response, data } = await stringifyBody(res); + try { + const remoteHTTP = await parseRefsAdResponse([data], { service }); + remoteHTTP.auth = auth; + return remoteHTTP; + } catch (e) { + throw new SmartHttpError(preview, response); + } + } + } + /** + * @param {Object} args + * @param {HttpClient} args.http + * @param {ProgressCallback} [args.onProgress] + * @param {string} [args.corsProxy] + * @param {string} args.service + * @param {string} args.url + * @param {Object} [args.headers] + * @param {any} args.body + * @param {any} args.auth + */ + static async connect({ + http, + onProgress, + corsProxy, + service, + url, + auth, + body, + headers + }) { + const urlAuth = extractAuthFromUrl(url); + if (urlAuth) + url = urlAuth.url; + if (corsProxy) + url = corsProxify(corsProxy, url); + headers["content-type"] = `application/x-${service}-request`; + headers.accept = `application/x-${service}-result`; + updateHeaders(headers, auth); + const res = await http.request({ + onProgress, + method: "POST", + url: `${url}/${service}`, + body, + headers + }); + if (res.statusCode !== 200) { + const { response } = stringifyBody(res); + throw new HttpError(res.statusCode, res.statusMessage, response); + } + return res; + } +}; +function parseRemoteUrl({ url }) { + if (url.startsWith("git@")) { + return { + transport: "ssh", + address: url + }; + } + const matches = url.match(/(\w+)(:\/\/|::)(.*)/); + if (matches === null) + return; + if (matches[2] === "://") { + return { + transport: matches[1], + address: matches[0] + }; + } + if (matches[2] === "::") { + return { + transport: matches[1], + address: matches[3] + }; + } +} +var GitRemoteManager = class { + static getRemoteHelperFor({ url }) { + const remoteHelpers = /* @__PURE__ */ new Map(); + remoteHelpers.set("http", GitRemoteHTTP); + remoteHelpers.set("https", GitRemoteHTTP); + const parts = parseRemoteUrl({ url }); + if (!parts) { + throw new UrlParseError(url); + } + if (remoteHelpers.has(parts.transport)) { + return remoteHelpers.get(parts.transport); + } + throw new UnknownTransportError( + url, + parts.transport, + parts.transport === "ssh" ? translateSSHtoHTTP(url) : void 0 + ); + } +}; +var lock$1 = null; +var GitShallowManager = class { + static async read({ fs, gitdir }) { + if (lock$1 === null) + lock$1 = new import_async_lock.default(); + const filepath = join(gitdir, "shallow"); + const oids = /* @__PURE__ */ new Set(); + await lock$1.acquire(filepath, async function() { + const text2 = await fs.read(filepath, { encoding: "utf8" }); + if (text2 === null) + return oids; + if (text2.trim() === "") + return oids; + text2.trim().split("\n").map((oid) => oids.add(oid)); + }); + return oids; + } + static async write({ fs, gitdir, oids }) { + if (lock$1 === null) + lock$1 = new import_async_lock.default(); + const filepath = join(gitdir, "shallow"); + if (oids.size > 0) { + const text2 = [...oids].join("\n") + "\n"; + await lock$1.acquire(filepath, async function() { + await fs.write(filepath, text2, { + encoding: "utf8" + }); + }); + } else { + await lock$1.acquire(filepath, async function() { + await fs.rm(filepath); + }); + } + } +}; +async function hasObjectLoose({ fs, gitdir, oid }) { + const source = `objects/${oid.slice(0, 2)}/${oid.slice(2)}`; + return fs.exists(`${gitdir}/${source}`); +} +async function hasObjectPacked({ + fs, + cache, + gitdir, + oid, + getExternalRefDelta +}) { + let list = await fs.readdir(join(gitdir, "objects/pack")); + list = list.filter((x) => x.endsWith(".idx")); + for (const filename of list) { + const indexFile = `${gitdir}/objects/pack/${filename}`; + const p = await readPackIndex({ + fs, + cache, + filename: indexFile, + getExternalRefDelta + }); + if (p.error) + throw new InternalError(p.error); + if (p.offsets.has(oid)) { + return true; + } + } + return false; +} +async function hasObject({ + fs, + cache, + gitdir, + oid, + format = "content" +}) { + const getExternalRefDelta = (oid2) => _readObject({ fs, cache, gitdir, oid: oid2 }); + let result = await hasObjectLoose({ fs, gitdir, oid }); + if (!result) { + result = await hasObjectPacked({ + fs, + cache, + gitdir, + oid, + getExternalRefDelta + }); + } + return result; +} +function emptyPackfile(pack) { + const pheader = "5041434b"; + const version2 = "00000002"; + const obCount = "00000000"; + const header = pheader + version2 + obCount; + return pack.slice(0, 12).toString("hex") === header; +} +function filterCapabilities(server, client) { + const serverNames = server.map((cap) => cap.split("=", 1)[0]); + return client.filter((cap) => { + const name = cap.split("=", 1)[0]; + return serverNames.includes(name); + }); +} +var pkg = { + name: "isomorphic-git", + version: "1.24.2", + agent: "git/isomorphic-git@1.24.2" +}; +var FIFO = class { + constructor() { + this._queue = []; + } + write(chunk) { + if (this._ended) { + throw Error("You cannot write to a FIFO that has already been ended!"); + } + if (this._waiting) { + const resolve = this._waiting; + this._waiting = null; + resolve({ value: chunk }); + } else { + this._queue.push(chunk); + } + } + end() { + this._ended = true; + if (this._waiting) { + const resolve = this._waiting; + this._waiting = null; + resolve({ done: true }); + } + } + destroy(err) { + this._ended = true; + this.error = err; + } + async next() { + if (this._queue.length > 0) { + return { value: this._queue.shift() }; + } + if (this._ended) { + return { done: true }; + } + if (this._waiting) { + throw Error( + "You cannot call read until the previous call to read has returned!" + ); + } + return new Promise((resolve) => { + this._waiting = resolve; + }); + } +}; +function findSplit(str) { + const r = str.indexOf("\r"); + const n = str.indexOf("\n"); + if (r === -1 && n === -1) + return -1; + if (r === -1) + return n + 1; + if (n === -1) + return r + 1; + if (n === r + 1) + return n + 1; + return Math.min(r, n) + 1; +} +function splitLines(input) { + const output = new FIFO(); + let tmp = ""; + (async () => { + await forAwait(input, (chunk) => { + chunk = chunk.toString("utf8"); + tmp += chunk; + while (true) { + const i = findSplit(tmp); + if (i === -1) + break; + output.write(tmp.slice(0, i)); + tmp = tmp.slice(i); + } + }); + if (tmp.length > 0) { + output.write(tmp); + } + output.end(); + })(); + return output; +} +var GitSideBand = class { + static demux(input) { + const read = GitPktLine.streamReader(input); + const packetlines = new FIFO(); + const packfile = new FIFO(); + const progress = new FIFO(); + const nextBit = async function() { + const line = await read(); + if (line === null) + return nextBit(); + if (line === true) { + packetlines.end(); + progress.end(); + packfile.end(); + return; + } + switch (line[0]) { + case 1: { + packfile.write(line.slice(1)); + break; + } + case 2: { + progress.write(line.slice(1)); + break; + } + case 3: { + const error = line.slice(1); + progress.write(error); + packfile.destroy(new Error(error.toString("utf8"))); + return; + } + default: { + packetlines.write(line.slice(0)); + } + } + nextBit(); + }; + nextBit(); + return { + packetlines, + packfile, + progress + }; + } + // static mux ({ + // protocol, // 'side-band' or 'side-band-64k' + // packetlines, + // packfile, + // progress, + // error + // }) { + // const MAX_PACKET_LENGTH = protocol === 'side-band-64k' ? 999 : 65519 + // let output = new PassThrough() + // packetlines.on('data', data => { + // if (data === null) { + // output.write(GitPktLine.flush()) + // } else { + // output.write(GitPktLine.encode(data)) + // } + // }) + // let packfileWasEmpty = true + // let packfileEnded = false + // let progressEnded = false + // let errorEnded = false + // let goodbye = Buffer.concat([ + // GitPktLine.encode(Buffer.from('010A', 'hex')), + // GitPktLine.flush() + // ]) + // packfile + // .on('data', data => { + // packfileWasEmpty = false + // const buffers = splitBuffer(data, MAX_PACKET_LENGTH) + // for (const buffer of buffers) { + // output.write( + // GitPktLine.encode(Buffer.concat([Buffer.from('01', 'hex'), buffer])) + // ) + // } + // }) + // .on('end', () => { + // packfileEnded = true + // if (!packfileWasEmpty) output.write(goodbye) + // if (progressEnded && errorEnded) output.end() + // }) + // progress + // .on('data', data => { + // const buffers = splitBuffer(data, MAX_PACKET_LENGTH) + // for (const buffer of buffers) { + // output.write( + // GitPktLine.encode(Buffer.concat([Buffer.from('02', 'hex'), buffer])) + // ) + // } + // }) + // .on('end', () => { + // progressEnded = true + // if (packfileEnded && errorEnded) output.end() + // }) + // error + // .on('data', data => { + // const buffers = splitBuffer(data, MAX_PACKET_LENGTH) + // for (const buffer of buffers) { + // output.write( + // GitPktLine.encode(Buffer.concat([Buffer.from('03', 'hex'), buffer])) + // ) + // } + // }) + // .on('end', () => { + // errorEnded = true + // if (progressEnded && packfileEnded) output.end() + // }) + // return output + // } +}; +async function parseUploadPackResponse(stream) { + const { packetlines, packfile, progress } = GitSideBand.demux(stream); + const shallows = []; + const unshallows = []; + const acks = []; + let nak = false; + let done = false; + return new Promise((resolve, reject) => { + forAwait(packetlines, (data) => { + const line = data.toString("utf8").trim(); + if (line.startsWith("shallow")) { + const oid = line.slice(-41).trim(); + if (oid.length !== 40) { + reject(new InvalidOidError(oid)); + } + shallows.push(oid); + } else if (line.startsWith("unshallow")) { + const oid = line.slice(-41).trim(); + if (oid.length !== 40) { + reject(new InvalidOidError(oid)); + } + unshallows.push(oid); + } else if (line.startsWith("ACK")) { + const [, oid, status2] = line.split(" "); + acks.push({ oid, status: status2 }); + if (!status2) + done = true; + } else if (line.startsWith("NAK")) { + nak = true; + done = true; + } + if (done) { + resolve({ shallows, unshallows, acks, nak, packfile, progress }); + } + }); + }); +} +function writeUploadPackRequest({ + capabilities = [], + wants = [], + haves = [], + shallows = [], + depth = null, + since = null, + exclude = [] +}) { + const packstream = []; + wants = [...new Set(wants)]; + let firstLineCapabilities = ` ${capabilities.join(" ")}`; + for (const oid of wants) { + packstream.push(GitPktLine.encode(`want ${oid}${firstLineCapabilities} +`)); + firstLineCapabilities = ""; + } + for (const oid of shallows) { + packstream.push(GitPktLine.encode(`shallow ${oid} +`)); + } + if (depth !== null) { + packstream.push(GitPktLine.encode(`deepen ${depth} +`)); + } + if (since !== null) { + packstream.push( + GitPktLine.encode(`deepen-since ${Math.floor(since.valueOf() / 1e3)} +`) + ); + } + for (const oid of exclude) { + packstream.push(GitPktLine.encode(`deepen-not ${oid} +`)); + } + packstream.push(GitPktLine.flush()); + for (const oid of haves) { + packstream.push(GitPktLine.encode(`have ${oid} +`)); + } + packstream.push(GitPktLine.encode(`done +`)); + return packstream; +} +async function _fetch({ + fs, + cache, + http, + onProgress, + onMessage, + onAuth, + onAuthSuccess, + onAuthFailure, + gitdir, + ref: _ref, + remoteRef: _remoteRef, + remote: _remote, + url: _url, + corsProxy, + depth = null, + since = null, + exclude = [], + relative: relative2 = false, + tags = false, + singleBranch = false, + headers = {}, + prune = false, + pruneTags = false +}) { + const ref = _ref || await _currentBranch({ fs, gitdir, test: true }); + const config = await GitConfigManager.get({ fs, gitdir }); + const remote = _remote || ref && await config.get(`branch.${ref}.remote`) || "origin"; + const url = _url || await config.get(`remote.${remote}.url`); + if (typeof url === "undefined") { + throw new MissingParameterError("remote OR url"); + } + const remoteRef = _remoteRef || ref && await config.get(`branch.${ref}.merge`) || _ref || "HEAD"; + if (corsProxy === void 0) { + corsProxy = await config.get("http.corsProxy"); + } + const GitRemoteHTTP2 = GitRemoteManager.getRemoteHelperFor({ url }); + const remoteHTTP = await GitRemoteHTTP2.discover({ + http, + onAuth, + onAuthSuccess, + onAuthFailure, + corsProxy, + service: "git-upload-pack", + url, + headers, + protocolVersion: 1 + }); + const auth = remoteHTTP.auth; + const remoteRefs = remoteHTTP.refs; + if (remoteRefs.size === 0) { + return { + defaultBranch: null, + fetchHead: null, + fetchHeadDescription: null + }; + } + if (depth !== null && !remoteHTTP.capabilities.has("shallow")) { + throw new RemoteCapabilityError("shallow", "depth"); + } + if (since !== null && !remoteHTTP.capabilities.has("deepen-since")) { + throw new RemoteCapabilityError("deepen-since", "since"); + } + if (exclude.length > 0 && !remoteHTTP.capabilities.has("deepen-not")) { + throw new RemoteCapabilityError("deepen-not", "exclude"); + } + if (relative2 === true && !remoteHTTP.capabilities.has("deepen-relative")) { + throw new RemoteCapabilityError("deepen-relative", "relative"); + } + const { oid, fullref } = GitRefManager.resolveAgainstMap({ + ref: remoteRef, + map: remoteRefs + }); + for (const remoteRef2 of remoteRefs.keys()) { + if (remoteRef2 === fullref || remoteRef2 === "HEAD" || remoteRef2.startsWith("refs/heads/") || tags && remoteRef2.startsWith("refs/tags/")) { + continue; + } + remoteRefs.delete(remoteRef2); + } + const capabilities = filterCapabilities( + [...remoteHTTP.capabilities], + [ + "multi_ack_detailed", + "no-done", + "side-band-64k", + // Note: I removed 'thin-pack' option since our code doesn't "fatten" packfiles, + // which is necessary for compatibility with git. It was the cause of mysterious + // 'fatal: pack has [x] unresolved deltas' errors that plagued us for some time. + // isomorphic-git is perfectly happy with thin packfiles in .git/objects/pack but + // canonical git it turns out is NOT. + "ofs-delta", + `agent=${pkg.agent}` + ] + ); + if (relative2) + capabilities.push("deepen-relative"); + const wants = singleBranch ? [oid] : remoteRefs.values(); + const haveRefs = singleBranch ? [ref] : await GitRefManager.listRefs({ + fs, + gitdir, + filepath: `refs` + }); + let haves = []; + for (let ref2 of haveRefs) { + try { + ref2 = await GitRefManager.expand({ fs, gitdir, ref: ref2 }); + const oid2 = await GitRefManager.resolve({ fs, gitdir, ref: ref2 }); + if (await hasObject({ fs, cache, gitdir, oid: oid2 })) { + haves.push(oid2); + } + } catch (err) { + } + } + haves = [...new Set(haves)]; + const oids = await GitShallowManager.read({ fs, gitdir }); + const shallows = remoteHTTP.capabilities.has("shallow") ? [...oids] : []; + const packstream = writeUploadPackRequest({ + capabilities, + wants, + haves, + shallows, + depth, + since, + exclude + }); + const packbuffer = Buffer.from(await collect(packstream)); + const raw = await GitRemoteHTTP2.connect({ + http, + onProgress, + corsProxy, + service: "git-upload-pack", + url, + auth, + body: [packbuffer], + headers + }); + const response = await parseUploadPackResponse(raw.body); + if (raw.headers) { + response.headers = raw.headers; + } + for (const oid2 of response.shallows) { + if (!oids.has(oid2)) { + try { + const { object } = await _readObject({ fs, cache, gitdir, oid: oid2 }); + const commit2 = new GitCommit(object); + const hasParents = await Promise.all( + commit2.headers().parent.map((oid3) => hasObject({ fs, cache, gitdir, oid: oid3 })) + ); + const haveAllParents = hasParents.length === 0 || hasParents.every((has) => has); + if (!haveAllParents) { + oids.add(oid2); + } + } catch (err) { + oids.add(oid2); + } + } + } + for (const oid2 of response.unshallows) { + oids.delete(oid2); + } + await GitShallowManager.write({ fs, gitdir, oids }); + if (singleBranch) { + const refs = /* @__PURE__ */ new Map([[fullref, oid]]); + const symrefs = /* @__PURE__ */ new Map(); + let bail = 10; + let key2 = fullref; + while (bail--) { + const value = remoteHTTP.symrefs.get(key2); + if (value === void 0) + break; + symrefs.set(key2, value); + key2 = value; + } + const realRef = remoteRefs.get(key2); + if (realRef) { + refs.set(key2, realRef); + } + const { pruned } = await GitRefManager.updateRemoteRefs({ + fs, + gitdir, + remote, + refs, + symrefs, + tags, + prune + }); + if (prune) { + response.pruned = pruned; + } + } else { + const { pruned } = await GitRefManager.updateRemoteRefs({ + fs, + gitdir, + remote, + refs: remoteRefs, + symrefs: remoteHTTP.symrefs, + tags, + prune, + pruneTags + }); + if (prune) { + response.pruned = pruned; + } + } + response.HEAD = remoteHTTP.symrefs.get("HEAD"); + if (response.HEAD === void 0) { + const { oid: oid2 } = GitRefManager.resolveAgainstMap({ + ref: "HEAD", + map: remoteRefs + }); + for (const [key2, value] of remoteRefs.entries()) { + if (key2 !== "HEAD" && value === oid2) { + response.HEAD = key2; + break; + } + } + } + const noun = fullref.startsWith("refs/tags") ? "tag" : "branch"; + response.FETCH_HEAD = { + oid, + description: `${noun} '${abbreviateRef(fullref)}' of ${url}` + }; + if (onProgress || onMessage) { + const lines = splitLines(response.progress); + forAwait(lines, async (line) => { + if (onMessage) + await onMessage(line); + if (onProgress) { + const matches = line.match(/([^:]*).*\((\d+?)\/(\d+?)\)/); + if (matches) { + await onProgress({ + phase: matches[1].trim(), + loaded: parseInt(matches[2], 10), + total: parseInt(matches[3], 10) + }); + } + } + }); + } + const packfile = Buffer.from(await collect(response.packfile)); + const packfileSha = packfile.slice(-20).toString("hex"); + const res = { + defaultBranch: response.HEAD, + fetchHead: response.FETCH_HEAD.oid, + fetchHeadDescription: response.FETCH_HEAD.description + }; + if (response.headers) { + res.headers = response.headers; + } + if (prune) { + res.pruned = response.pruned; + } + if (packfileSha !== "" && !emptyPackfile(packfile)) { + res.packfile = `objects/pack/pack-${packfileSha}.pack`; + const fullpath = join(gitdir, res.packfile); + await fs.write(fullpath, packfile); + const getExternalRefDelta = (oid2) => _readObject({ fs, cache, gitdir, oid: oid2 }); + const idx = await GitPackIndex.fromPack({ + pack: packfile, + getExternalRefDelta, + onProgress + }); + await fs.write(fullpath.replace(/\.pack$/, ".idx"), await idx.toBuffer()); + } + return res; +} +async function _init({ + fs, + bare = false, + dir, + gitdir = bare ? dir : join(dir, ".git"), + defaultBranch = "master" +}) { + if (await fs.exists(gitdir + "/config")) + return; + let folders = [ + "hooks", + "info", + "objects/info", + "objects/pack", + "refs/heads", + "refs/tags" + ]; + folders = folders.map((dir2) => gitdir + "/" + dir2); + for (const folder of folders) { + await fs.mkdir(folder); + } + await fs.write( + gitdir + "/config", + `[core] + repositoryformatversion = 0 + filemode = false + bare = ${bare} +` + (bare ? "" : " logallrefupdates = true\n") + " symlinks = false\n ignorecase = true\n" + ); + await fs.write(gitdir + "/HEAD", `ref: refs/heads/${defaultBranch} +`); +} +async function _clone({ + fs, + cache, + http, + onProgress, + onMessage, + onAuth, + onAuthSuccess, + onAuthFailure, + dir, + gitdir, + url, + corsProxy, + ref, + remote, + depth, + since, + exclude, + relative: relative2, + singleBranch, + noCheckout, + noTags, + headers +}) { + try { + await _init({ fs, gitdir }); + await _addRemote({ fs, gitdir, remote, url, force: false }); + if (corsProxy) { + const config = await GitConfigManager.get({ fs, gitdir }); + await config.set(`http.corsProxy`, corsProxy); + await GitConfigManager.save({ fs, gitdir, config }); + } + const { defaultBranch, fetchHead } = await _fetch({ + fs, + cache, + http, + onProgress, + onMessage, + onAuth, + onAuthSuccess, + onAuthFailure, + gitdir, + ref, + remote, + corsProxy, + depth, + since, + exclude, + relative: relative2, + singleBranch, + headers, + tags: !noTags + }); + if (fetchHead === null) + return; + ref = ref || defaultBranch; + ref = ref.replace("refs/heads/", ""); + await _checkout({ + fs, + cache, + onProgress, + dir, + gitdir, + ref, + remote, + noCheckout + }); + } catch (err) { + await fs.rmdir(gitdir, { recursive: true, maxRetries: 10 }).catch(() => void 0); + throw err; + } +} +async function clone({ + fs, + http, + onProgress, + onMessage, + onAuth, + onAuthSuccess, + onAuthFailure, + dir, + gitdir = join(dir, ".git"), + url, + corsProxy = void 0, + ref = void 0, + remote = "origin", + depth = void 0, + since = void 0, + exclude = [], + relative: relative2 = false, + singleBranch = false, + noCheckout = false, + noTags = false, + headers = {}, + cache = {} +}) { + try { + assertParameter("fs", fs); + assertParameter("http", http); + assertParameter("gitdir", gitdir); + if (!noCheckout) { + assertParameter("dir", dir); + } + assertParameter("url", url); + return await _clone({ + fs: new FileSystem(fs), + cache, + http, + onProgress, + onMessage, + onAuth, + onAuthSuccess, + onAuthFailure, + dir, + gitdir, + url, + corsProxy, + ref, + remote, + depth, + since, + exclude, + relative: relative2, + singleBranch, + noCheckout, + noTags, + headers + }); + } catch (err) { + err.caller = "git.clone"; + throw err; + } +} +async function commit({ + fs: _fs, + onSign, + dir, + gitdir = join(dir, ".git"), + message, + author: _author, + committer: _committer, + signingKey, + dryRun = false, + noUpdateBranch = false, + ref, + parent, + tree, + cache = {} +}) { + try { + assertParameter("fs", _fs); + assertParameter("message", message); + if (signingKey) { + assertParameter("onSign", onSign); + } + const fs = new FileSystem(_fs); + const author = await normalizeAuthorObject({ fs, gitdir, author: _author }); + if (!author) + throw new MissingNameError("author"); + const committer = await normalizeCommitterObject({ + fs, + gitdir, + author, + committer: _committer + }); + if (!committer) + throw new MissingNameError("committer"); + return await _commit({ + fs, + cache, + onSign, + gitdir, + message, + author, + committer, + signingKey, + dryRun, + noUpdateBranch, + ref, + parent, + tree + }); + } catch (err) { + err.caller = "git.commit"; + throw err; + } +} +async function currentBranch({ + fs, + dir, + gitdir = join(dir, ".git"), + fullname = false, + test = false +}) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + return await _currentBranch({ + fs: new FileSystem(fs), + gitdir, + fullname, + test + }); + } catch (err) { + err.caller = "git.currentBranch"; + throw err; + } +} +async function _deleteBranch({ fs, gitdir, ref }) { + ref = ref.startsWith("refs/heads/") ? ref : `refs/heads/${ref}`; + const exist = await GitRefManager.exists({ fs, gitdir, ref }); + if (!exist) { + throw new NotFoundError(ref); + } + const fullRef = await GitRefManager.expand({ fs, gitdir, ref }); + const currentRef = await _currentBranch({ fs, gitdir, fullname: true }); + if (fullRef === currentRef) { + const value = await GitRefManager.resolve({ fs, gitdir, ref: fullRef }); + await GitRefManager.writeRef({ fs, gitdir, ref: "HEAD", value }); + } + await GitRefManager.deleteRef({ fs, gitdir, ref: fullRef }); +} +async function deleteBranch({ + fs, + dir, + gitdir = join(dir, ".git"), + ref +}) { + try { + assertParameter("fs", fs); + assertParameter("ref", ref); + return await _deleteBranch({ + fs: new FileSystem(fs), + gitdir, + ref + }); + } catch (err) { + err.caller = "git.deleteBranch"; + throw err; + } +} +async function deleteRef({ fs, dir, gitdir = join(dir, ".git"), ref }) { + try { + assertParameter("fs", fs); + assertParameter("ref", ref); + await GitRefManager.deleteRef({ fs: new FileSystem(fs), gitdir, ref }); + } catch (err) { + err.caller = "git.deleteRef"; + throw err; + } +} +async function _deleteRemote({ fs, gitdir, remote }) { + const config = await GitConfigManager.get({ fs, gitdir }); + await config.deleteSection("remote", remote); + await GitConfigManager.save({ fs, gitdir, config }); +} +async function deleteRemote({ + fs, + dir, + gitdir = join(dir, ".git"), + remote +}) { + try { + assertParameter("fs", fs); + assertParameter("remote", remote); + return await _deleteRemote({ + fs: new FileSystem(fs), + gitdir, + remote + }); + } catch (err) { + err.caller = "git.deleteRemote"; + throw err; + } +} +async function _deleteTag({ fs, gitdir, ref }) { + ref = ref.startsWith("refs/tags/") ? ref : `refs/tags/${ref}`; + await GitRefManager.deleteRef({ fs, gitdir, ref }); +} +async function deleteTag({ fs, dir, gitdir = join(dir, ".git"), ref }) { + try { + assertParameter("fs", fs); + assertParameter("ref", ref); + return await _deleteTag({ + fs: new FileSystem(fs), + gitdir, + ref + }); + } catch (err) { + err.caller = "git.deleteTag"; + throw err; + } +} +async function expandOidLoose({ fs, gitdir, oid: short }) { + const prefix = short.slice(0, 2); + const objectsSuffixes = await fs.readdir(`${gitdir}/objects/${prefix}`); + return objectsSuffixes.map((suffix) => `${prefix}${suffix}`).filter((_oid) => _oid.startsWith(short)); +} +async function expandOidPacked({ + fs, + cache, + gitdir, + oid: short, + getExternalRefDelta +}) { + const results = []; + let list = await fs.readdir(join(gitdir, "objects/pack")); + list = list.filter((x) => x.endsWith(".idx")); + for (const filename of list) { + const indexFile = `${gitdir}/objects/pack/${filename}`; + const p = await readPackIndex({ + fs, + cache, + filename: indexFile, + getExternalRefDelta + }); + if (p.error) + throw new InternalError(p.error); + for (const oid of p.offsets.keys()) { + if (oid.startsWith(short)) + results.push(oid); + } + } + return results; +} +async function _expandOid({ fs, cache, gitdir, oid: short }) { + const getExternalRefDelta = (oid) => _readObject({ fs, cache, gitdir, oid }); + const results1 = await expandOidLoose({ fs, gitdir, oid: short }); + const results2 = await expandOidPacked({ + fs, + cache, + gitdir, + oid: short, + getExternalRefDelta + }); + const results = results1.concat(results2); + if (results.length === 1) { + return results[0]; + } + if (results.length > 1) { + throw new AmbiguousError("oids", short, results); + } + throw new NotFoundError(`an object matching "${short}"`); +} +async function expandOid({ + fs, + dir, + gitdir = join(dir, ".git"), + oid, + cache = {} +}) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + assertParameter("oid", oid); + return await _expandOid({ + fs: new FileSystem(fs), + cache, + gitdir, + oid + }); + } catch (err) { + err.caller = "git.expandOid"; + throw err; + } +} +async function expandRef({ fs, dir, gitdir = join(dir, ".git"), ref }) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + assertParameter("ref", ref); + return await GitRefManager.expand({ + fs: new FileSystem(fs), + gitdir, + ref + }); + } catch (err) { + err.caller = "git.expandRef"; + throw err; + } +} +async function _findMergeBase({ fs, cache, gitdir, oids }) { + const visits = {}; + const passes = oids.length; + let heads = oids.map((oid, index2) => ({ index: index2, oid })); + while (heads.length) { + const result = /* @__PURE__ */ new Set(); + for (const { oid, index: index2 } of heads) { + if (!visits[oid]) + visits[oid] = /* @__PURE__ */ new Set(); + visits[oid].add(index2); + if (visits[oid].size === passes) { + result.add(oid); + } + } + if (result.size > 0) { + return [...result]; + } + const newheads = /* @__PURE__ */ new Map(); + for (const { oid, index: index2 } of heads) { + try { + const { object } = await _readObject({ fs, cache, gitdir, oid }); + const commit2 = GitCommit.from(object); + const { parent } = commit2.parseHeaders(); + for (const oid2 of parent) { + if (!visits[oid2] || !visits[oid2].has(index2)) { + newheads.set(oid2 + ":" + index2, { oid: oid2, index: index2 }); + } + } + } catch (err) { + } + } + heads = Array.from(newheads.values()); + } + return []; +} +var LINEBREAKS = /^.*(\r?\n|$)/gm; +function mergeFile({ branches, contents }) { + const ourName = branches[1]; + const theirName = branches[2]; + const baseContent = contents[0]; + const ourContent = contents[1]; + const theirContent = contents[2]; + const ours = ourContent.match(LINEBREAKS); + const base = baseContent.match(LINEBREAKS); + const theirs = theirContent.match(LINEBREAKS); + const result = (0, import_diff3.default)(ours, base, theirs); + const markerSize = 7; + let mergedText = ""; + let cleanMerge = true; + for (const item of result) { + if (item.ok) { + mergedText += item.ok.join(""); + } + if (item.conflict) { + cleanMerge = false; + mergedText += `${"<".repeat(markerSize)} ${ourName} +`; + mergedText += item.conflict.a.join(""); + mergedText += `${"=".repeat(markerSize)} +`; + mergedText += item.conflict.b.join(""); + mergedText += `${">".repeat(markerSize)} ${theirName} +`; + } + } + return { cleanMerge, mergedText }; +} +async function mergeTree({ + fs, + cache, + dir, + gitdir = join(dir, ".git"), + index: index2, + ourOid, + baseOid, + theirOid, + ourName = "ours", + baseName = "base", + theirName = "theirs", + dryRun = false, + abortOnConflict = true, + mergeDriver +}) { + const ourTree = TREE({ ref: ourOid }); + const baseTree = TREE({ ref: baseOid }); + const theirTree = TREE({ ref: theirOid }); + const unmergedFiles = []; + const results = await _walk({ + fs, + cache, + dir, + gitdir, + trees: [ourTree, baseTree, theirTree], + map: async function(filepath, [ours, base, theirs]) { + const path2 = basename(filepath); + const ourChange = await modified(ours, base); + const theirChange = await modified(theirs, base); + switch (`${ourChange}-${theirChange}`) { + case "false-false": { + return { + mode: await base.mode(), + path: path2, + oid: await base.oid(), + type: await base.type() + }; + } + case "false-true": { + return theirs ? { + mode: await theirs.mode(), + path: path2, + oid: await theirs.oid(), + type: await theirs.type() + } : void 0; + } + case "true-false": { + return ours ? { + mode: await ours.mode(), + path: path2, + oid: await ours.oid(), + type: await ours.type() + } : void 0; + } + case "true-true": { + if (ours && base && theirs && await ours.type() === "blob" && await base.type() === "blob" && await theirs.type() === "blob") { + return mergeBlobs({ + fs, + gitdir, + path: path2, + ours, + base, + theirs, + ourName, + baseName, + theirName, + mergeDriver + }).then(async (r) => { + if (!r.cleanMerge) { + unmergedFiles.push(filepath); + if (!abortOnConflict) { + const baseOid2 = await base.oid(); + const ourOid2 = await ours.oid(); + const theirOid2 = await theirs.oid(); + index2.delete({ filepath }); + index2.insert({ filepath, oid: baseOid2, stage: 1 }); + index2.insert({ filepath, oid: ourOid2, stage: 2 }); + index2.insert({ filepath, oid: theirOid2, stage: 3 }); + } + } else if (!abortOnConflict) { + index2.insert({ filepath, oid: r.mergeResult.oid, stage: 0 }); + } + return r.mergeResult; + }); + } + throw new MergeNotSupportedError(); + } + } + }, + /** + * @param {TreeEntry} [parent] + * @param {Array} children + */ + reduce: unmergedFiles.length !== 0 && (!dir || abortOnConflict) ? void 0 : async (parent, children2) => { + const entries = children2.filter(Boolean); + if (!parent) + return; + if (parent && parent.type === "tree" && entries.length === 0) + return; + if (entries.length > 0) { + const tree = new GitTree(entries); + const object = tree.toObject(); + const oid = await _writeObject({ + fs, + gitdir, + type: "tree", + object, + dryRun + }); + parent.oid = oid; + } + return parent; + } + }); + if (unmergedFiles.length !== 0) { + if (dir && !abortOnConflict) { + await _walk({ + fs, + cache, + dir, + gitdir, + trees: [TREE({ ref: results.oid })], + map: async function(filepath, [entry]) { + const path2 = `${dir}/${filepath}`; + if (await entry.type() === "blob") { + const mode = await entry.mode(); + const content = new TextDecoder().decode(await entry.content()); + await fs.write(path2, content, { mode }); + } + return true; + } + }); + } + return new MergeConflictError(unmergedFiles); + } + return results.oid; +} +async function mergeBlobs({ + fs, + gitdir, + path: path2, + ours, + base, + theirs, + ourName, + theirName, + baseName, + dryRun, + mergeDriver = mergeFile +}) { + const type = "blob"; + const mode = await base.mode() === await ours.mode() ? await theirs.mode() : await ours.mode(); + if (await ours.oid() === await theirs.oid()) { + return { + cleanMerge: true, + mergeResult: { mode, path: path2, oid: await ours.oid(), type } + }; + } + if (await ours.oid() === await base.oid()) { + return { + cleanMerge: true, + mergeResult: { mode, path: path2, oid: await theirs.oid(), type } + }; + } + if (await theirs.oid() === await base.oid()) { + return { + cleanMerge: true, + mergeResult: { mode, path: path2, oid: await ours.oid(), type } + }; + } + const ourContent = Buffer.from(await ours.content()).toString("utf8"); + const baseContent = Buffer.from(await base.content()).toString("utf8"); + const theirContent = Buffer.from(await theirs.content()).toString("utf8"); + const { mergedText, cleanMerge } = await mergeDriver({ + branches: [baseName, ourName, theirName], + contents: [baseContent, ourContent, theirContent], + path: path2 + }); + const oid = await _writeObject({ + fs, + gitdir, + type: "blob", + object: Buffer.from(mergedText, "utf8"), + dryRun + }); + return { cleanMerge, mergeResult: { mode, path: path2, oid, type } }; +} +async function _merge({ + fs, + cache, + dir, + gitdir, + ours, + theirs, + fastForward: fastForward2 = true, + fastForwardOnly = false, + dryRun = false, + noUpdateBranch = false, + abortOnConflict = true, + message, + author, + committer, + signingKey, + onSign, + mergeDriver +}) { + if (ours === void 0) { + ours = await _currentBranch({ fs, gitdir, fullname: true }); + } + ours = await GitRefManager.expand({ + fs, + gitdir, + ref: ours + }); + theirs = await GitRefManager.expand({ + fs, + gitdir, + ref: theirs + }); + const ourOid = await GitRefManager.resolve({ + fs, + gitdir, + ref: ours + }); + const theirOid = await GitRefManager.resolve({ + fs, + gitdir, + ref: theirs + }); + const baseOids = await _findMergeBase({ + fs, + cache, + gitdir, + oids: [ourOid, theirOid] + }); + if (baseOids.length !== 1) { + throw new MergeNotSupportedError(); + } + const baseOid = baseOids[0]; + if (baseOid === theirOid) { + return { + oid: ourOid, + alreadyMerged: true + }; + } + if (fastForward2 && baseOid === ourOid) { + if (!dryRun && !noUpdateBranch) { + await GitRefManager.writeRef({ fs, gitdir, ref: ours, value: theirOid }); + } + return { + oid: theirOid, + fastForward: true + }; + } else { + if (fastForwardOnly) { + throw new FastForwardError(); + } + const tree = await GitIndexManager.acquire( + { fs, gitdir, cache, allowUnmerged: false }, + async (index2) => { + return mergeTree({ + fs, + cache, + dir, + gitdir, + index: index2, + ourOid, + theirOid, + baseOid, + ourName: abbreviateRef(ours), + baseName: "base", + theirName: abbreviateRef(theirs), + dryRun, + abortOnConflict, + mergeDriver + }); + } + ); + if (tree instanceof MergeConflictError) + throw tree; + if (!message) { + message = `Merge branch '${abbreviateRef(theirs)}' into ${abbreviateRef( + ours + )}`; + } + const oid = await _commit({ + fs, + cache, + gitdir, + message, + ref: ours, + tree, + parent: [ourOid, theirOid], + author, + committer, + signingKey, + onSign, + dryRun, + noUpdateBranch + }); + return { + oid, + tree, + mergeCommit: true + }; + } +} +async function _pull({ + fs, + cache, + http, + onProgress, + onMessage, + onAuth, + onAuthSuccess, + onAuthFailure, + dir, + gitdir, + ref, + url, + remote, + remoteRef, + prune, + pruneTags, + fastForward: fastForward2, + fastForwardOnly, + corsProxy, + singleBranch, + headers, + author, + committer, + signingKey +}) { + try { + if (!ref) { + const head = await _currentBranch({ fs, gitdir }); + if (!head) { + throw new MissingParameterError("ref"); + } + ref = head; + } + const { fetchHead, fetchHeadDescription } = await _fetch({ + fs, + cache, + http, + onProgress, + onMessage, + onAuth, + onAuthSuccess, + onAuthFailure, + gitdir, + corsProxy, + ref, + url, + remote, + remoteRef, + singleBranch, + headers, + prune, + pruneTags + }); + await _merge({ + fs, + cache, + gitdir, + ours: ref, + theirs: fetchHead, + fastForward: fastForward2, + fastForwardOnly, + message: `Merge ${fetchHeadDescription}`, + author, + committer, + signingKey, + dryRun: false, + noUpdateBranch: false + }); + await _checkout({ + fs, + cache, + onProgress, + dir, + gitdir, + ref, + remote, + noCheckout: false + }); + } catch (err) { + err.caller = "git.pull"; + throw err; + } +} +async function fastForward({ + fs, + http, + onProgress, + onMessage, + onAuth, + onAuthSuccess, + onAuthFailure, + dir, + gitdir = join(dir, ".git"), + ref, + url, + remote, + remoteRef, + corsProxy, + singleBranch, + headers = {}, + cache = {} +}) { + try { + assertParameter("fs", fs); + assertParameter("http", http); + assertParameter("gitdir", gitdir); + const thisWillNotBeUsed = { + name: "", + email: "", + timestamp: Date.now(), + timezoneOffset: 0 + }; + return await _pull({ + fs: new FileSystem(fs), + cache, + http, + onProgress, + onMessage, + onAuth, + onAuthSuccess, + onAuthFailure, + dir, + gitdir, + ref, + url, + remote, + remoteRef, + fastForwardOnly: true, + corsProxy, + singleBranch, + headers, + author: thisWillNotBeUsed, + committer: thisWillNotBeUsed + }); + } catch (err) { + err.caller = "git.fastForward"; + throw err; + } +} +async function fetch({ + fs, + http, + onProgress, + onMessage, + onAuth, + onAuthSuccess, + onAuthFailure, + dir, + gitdir = join(dir, ".git"), + ref, + remote, + remoteRef, + url, + corsProxy, + depth = null, + since = null, + exclude = [], + relative: relative2 = false, + tags = false, + singleBranch = false, + headers = {}, + prune = false, + pruneTags = false, + cache = {} +}) { + try { + assertParameter("fs", fs); + assertParameter("http", http); + assertParameter("gitdir", gitdir); + return await _fetch({ + fs: new FileSystem(fs), + cache, + http, + onProgress, + onMessage, + onAuth, + onAuthSuccess, + onAuthFailure, + gitdir, + ref, + remote, + remoteRef, + url, + corsProxy, + depth, + since, + exclude, + relative: relative2, + tags, + singleBranch, + headers, + prune, + pruneTags + }); + } catch (err) { + err.caller = "git.fetch"; + throw err; + } +} +async function findMergeBase({ + fs, + dir, + gitdir = join(dir, ".git"), + oids, + cache = {} +}) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + assertParameter("oids", oids); + return await _findMergeBase({ + fs: new FileSystem(fs), + cache, + gitdir, + oids + }); + } catch (err) { + err.caller = "git.findMergeBase"; + throw err; + } +} +async function _findRoot({ fs, filepath }) { + if (await fs.exists(join(filepath, ".git"))) { + return filepath; + } else { + const parent = dirname(filepath); + if (parent === filepath) { + throw new NotFoundError(`git root for ${filepath}`); + } + return _findRoot({ fs, filepath: parent }); + } +} +async function findRoot({ fs, filepath }) { + try { + assertParameter("fs", fs); + assertParameter("filepath", filepath); + return await _findRoot({ fs: new FileSystem(fs), filepath }); + } catch (err) { + err.caller = "git.findRoot"; + throw err; + } +} +async function getConfig({ fs, dir, gitdir = join(dir, ".git"), path: path2 }) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + assertParameter("path", path2); + return await _getConfig({ + fs: new FileSystem(fs), + gitdir, + path: path2 + }); + } catch (err) { + err.caller = "git.getConfig"; + throw err; + } +} +async function _getConfigAll({ fs, gitdir, path: path2 }) { + const config = await GitConfigManager.get({ fs, gitdir }); + return config.getall(path2); +} +async function getConfigAll({ + fs, + dir, + gitdir = join(dir, ".git"), + path: path2 +}) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + assertParameter("path", path2); + return await _getConfigAll({ + fs: new FileSystem(fs), + gitdir, + path: path2 + }); + } catch (err) { + err.caller = "git.getConfigAll"; + throw err; + } +} +async function getRemoteInfo({ + http, + onAuth, + onAuthSuccess, + onAuthFailure, + corsProxy, + url, + headers = {}, + forPush = false +}) { + try { + assertParameter("http", http); + assertParameter("url", url); + const GitRemoteHTTP2 = GitRemoteManager.getRemoteHelperFor({ url }); + const remote = await GitRemoteHTTP2.discover({ + http, + onAuth, + onAuthSuccess, + onAuthFailure, + corsProxy, + service: forPush ? "git-receive-pack" : "git-upload-pack", + url, + headers, + protocolVersion: 1 + }); + const result = { + capabilities: [...remote.capabilities] + }; + for (const [ref, oid] of remote.refs) { + const parts = ref.split("/"); + const last2 = parts.pop(); + let o = result; + for (const part of parts) { + o[part] = o[part] || {}; + o = o[part]; + } + o[last2] = oid; + } + for (const [symref, ref] of remote.symrefs) { + const parts = symref.split("/"); + const last2 = parts.pop(); + let o = result; + for (const part of parts) { + o[part] = o[part] || {}; + o = o[part]; + } + o[last2] = ref; + } + return result; + } catch (err) { + err.caller = "git.getRemoteInfo"; + throw err; + } +} +function formatInfoRefs(remote, prefix, symrefs, peelTags) { + const refs = []; + for (const [key2, value] of remote.refs) { + if (prefix && !key2.startsWith(prefix)) + continue; + if (key2.endsWith("^{}")) { + if (peelTags) { + const _key = key2.replace("^{}", ""); + const last2 = refs[refs.length - 1]; + const r = last2.ref === _key ? last2 : refs.find((x) => x.ref === _key); + if (r === void 0) { + throw new Error("I did not expect this to happen"); + } + r.peeled = value; + } + continue; + } + const ref = { ref: key2, oid: value }; + if (symrefs) { + if (remote.symrefs.has(key2)) { + ref.target = remote.symrefs.get(key2); + } + } + refs.push(ref); + } + return refs; +} +async function getRemoteInfo2({ + http, + onAuth, + onAuthSuccess, + onAuthFailure, + corsProxy, + url, + headers = {}, + forPush = false, + protocolVersion = 2 +}) { + try { + assertParameter("http", http); + assertParameter("url", url); + const GitRemoteHTTP2 = GitRemoteManager.getRemoteHelperFor({ url }); + const remote = await GitRemoteHTTP2.discover({ + http, + onAuth, + onAuthSuccess, + onAuthFailure, + corsProxy, + service: forPush ? "git-receive-pack" : "git-upload-pack", + url, + headers, + protocolVersion + }); + if (remote.protocolVersion === 2) { + return { + protocolVersion: remote.protocolVersion, + capabilities: remote.capabilities2 + }; + } + const capabilities = {}; + for (const cap of remote.capabilities) { + const [key2, value] = cap.split("="); + if (value) { + capabilities[key2] = value; + } else { + capabilities[key2] = true; + } + } + return { + protocolVersion: 1, + capabilities, + refs: formatInfoRefs(remote, void 0, true, true) + }; + } catch (err) { + err.caller = "git.getRemoteInfo2"; + throw err; + } +} +async function hashObject({ + type, + object, + format = "content", + oid = void 0 +}) { + if (format !== "deflated") { + if (format !== "wrapped") { + object = GitObject.wrap({ type, object }); + } + oid = await shasum(object); + } + return { oid, object }; +} +async function hashBlob({ object }) { + try { + assertParameter("object", object); + if (typeof object === "string") { + object = Buffer.from(object, "utf8"); + } else { + object = Buffer.from(object); + } + const type = "blob"; + const { oid, object: _object } = await hashObject({ + type: "blob", + format: "content", + object + }); + return { oid, type, object: new Uint8Array(_object), format: "wrapped" }; + } catch (err) { + err.caller = "git.hashBlob"; + throw err; + } +} +async function _indexPack({ + fs, + cache, + onProgress, + dir, + gitdir, + filepath +}) { + try { + filepath = join(dir, filepath); + const pack = await fs.read(filepath); + const getExternalRefDelta = (oid) => _readObject({ fs, cache, gitdir, oid }); + const idx = await GitPackIndex.fromPack({ + pack, + getExternalRefDelta, + onProgress + }); + await fs.write(filepath.replace(/\.pack$/, ".idx"), await idx.toBuffer()); + return { + oids: [...idx.hashes] + }; + } catch (err) { + err.caller = "git.indexPack"; + throw err; + } +} +async function indexPack({ + fs, + onProgress, + dir, + gitdir = join(dir, ".git"), + filepath, + cache = {} +}) { + try { + assertParameter("fs", fs); + assertParameter("dir", dir); + assertParameter("gitdir", dir); + assertParameter("filepath", filepath); + return await _indexPack({ + fs: new FileSystem(fs), + cache, + onProgress, + dir, + gitdir, + filepath + }); + } catch (err) { + err.caller = "git.indexPack"; + throw err; + } +} +async function init({ + fs, + bare = false, + dir, + gitdir = bare ? dir : join(dir, ".git"), + defaultBranch = "master" +}) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + if (!bare) { + assertParameter("dir", dir); + } + return await _init({ + fs: new FileSystem(fs), + bare, + dir, + gitdir, + defaultBranch + }); + } catch (err) { + err.caller = "git.init"; + throw err; + } +} +async function _isDescendent({ + fs, + cache, + gitdir, + oid, + ancestor, + depth +}) { + const shallows = await GitShallowManager.read({ fs, gitdir }); + if (!oid) { + throw new MissingParameterError("oid"); + } + if (!ancestor) { + throw new MissingParameterError("ancestor"); + } + if (oid === ancestor) + return false; + const queue = [oid]; + const visited = /* @__PURE__ */ new Set(); + let searchdepth = 0; + while (queue.length) { + if (searchdepth++ === depth) { + throw new MaxDepthError(depth); + } + const oid2 = queue.shift(); + const { type, object } = await _readObject({ + fs, + cache, + gitdir, + oid: oid2 + }); + if (type !== "commit") { + throw new ObjectTypeError(oid2, type, "commit"); + } + const commit2 = GitCommit.from(object).parse(); + for (const parent of commit2.parent) { + if (parent === ancestor) + return true; + } + if (!shallows.has(oid2)) { + for (const parent of commit2.parent) { + if (!visited.has(parent)) { + queue.push(parent); + visited.add(parent); + } + } + } + } + return false; +} +async function isDescendent({ + fs, + dir, + gitdir = join(dir, ".git"), + oid, + ancestor, + depth = -1, + cache = {} +}) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + assertParameter("oid", oid); + assertParameter("ancestor", ancestor); + return await _isDescendent({ + fs: new FileSystem(fs), + cache, + gitdir, + oid, + ancestor, + depth + }); + } catch (err) { + err.caller = "git.isDescendent"; + throw err; + } +} +async function isIgnored({ + fs, + dir, + gitdir = join(dir, ".git"), + filepath +}) { + try { + assertParameter("fs", fs); + assertParameter("dir", dir); + assertParameter("gitdir", gitdir); + assertParameter("filepath", filepath); + return GitIgnoreManager.isIgnored({ + fs: new FileSystem(fs), + dir, + gitdir, + filepath + }); + } catch (err) { + err.caller = "git.isIgnored"; + throw err; + } +} +async function listBranches({ + fs, + dir, + gitdir = join(dir, ".git"), + remote +}) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + return GitRefManager.listBranches({ + fs: new FileSystem(fs), + gitdir, + remote + }); + } catch (err) { + err.caller = "git.listBranches"; + throw err; + } +} +async function _listFiles({ fs, gitdir, ref, cache }) { + if (ref) { + const oid = await GitRefManager.resolve({ gitdir, fs, ref }); + const filenames = []; + await accumulateFilesFromOid({ + fs, + cache, + gitdir, + oid, + filenames, + prefix: "" + }); + return filenames; + } else { + return GitIndexManager.acquire({ fs, gitdir, cache }, async function(index2) { + return index2.entries.map((x) => x.path); + }); + } +} +async function accumulateFilesFromOid({ + fs, + cache, + gitdir, + oid, + filenames, + prefix +}) { + const { tree } = await _readTree({ fs, cache, gitdir, oid }); + for (const entry of tree) { + if (entry.type === "tree") { + await accumulateFilesFromOid({ + fs, + cache, + gitdir, + oid: entry.oid, + filenames, + prefix: join(prefix, entry.path) + }); + } else { + filenames.push(join(prefix, entry.path)); + } + } +} +async function listFiles({ + fs, + dir, + gitdir = join(dir, ".git"), + ref, + cache = {} +}) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + return await _listFiles({ + fs: new FileSystem(fs), + cache, + gitdir, + ref + }); + } catch (err) { + err.caller = "git.listFiles"; + throw err; + } +} +async function _listNotes({ fs, cache, gitdir, ref }) { + let parent; + try { + parent = await GitRefManager.resolve({ gitdir, fs, ref }); + } catch (err) { + if (err instanceof NotFoundError) { + return []; + } + } + const result = await _readTree({ + fs, + cache, + gitdir, + oid: parent + }); + const notes = result.tree.map((entry) => ({ + target: entry.path, + note: entry.oid + })); + return notes; +} +async function listNotes({ + fs, + dir, + gitdir = join(dir, ".git"), + ref = "refs/notes/commits", + cache = {} +}) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + assertParameter("ref", ref); + return await _listNotes({ + fs: new FileSystem(fs), + cache, + gitdir, + ref + }); + } catch (err) { + err.caller = "git.listNotes"; + throw err; + } +} +async function _listRemotes({ fs, gitdir }) { + const config = await GitConfigManager.get({ fs, gitdir }); + const remoteNames = await config.getSubsections("remote"); + const remotes = Promise.all( + remoteNames.map(async (remote) => { + const url = await config.get(`remote.${remote}.url`); + return { remote, url }; + }) + ); + return remotes; +} +async function listRemotes({ fs, dir, gitdir = join(dir, ".git") }) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + return await _listRemotes({ + fs: new FileSystem(fs), + gitdir + }); + } catch (err) { + err.caller = "git.listRemotes"; + throw err; + } +} +async function parseListRefsResponse(stream) { + const read = GitPktLine.streamReader(stream); + const refs = []; + let line; + while (true) { + line = await read(); + if (line === true) + break; + if (line === null) + continue; + line = line.toString("utf8").replace(/\n$/, ""); + const [oid, ref, ...attrs] = line.split(" "); + const r = { ref, oid }; + for (const attr2 of attrs) { + const [name, value] = attr2.split(":"); + if (name === "symref-target") { + r.target = value; + } else if (name === "peeled") { + r.peeled = value; + } + } + refs.push(r); + } + return refs; +} +async function writeListRefsRequest({ prefix, symrefs, peelTags }) { + const packstream = []; + packstream.push(GitPktLine.encode("command=ls-refs\n")); + packstream.push(GitPktLine.encode(`agent=${pkg.agent} +`)); + if (peelTags || symrefs || prefix) { + packstream.push(GitPktLine.delim()); + } + if (peelTags) + packstream.push(GitPktLine.encode("peel")); + if (symrefs) + packstream.push(GitPktLine.encode("symrefs")); + if (prefix) + packstream.push(GitPktLine.encode(`ref-prefix ${prefix}`)); + packstream.push(GitPktLine.flush()); + return packstream; +} +async function listServerRefs({ + http, + onAuth, + onAuthSuccess, + onAuthFailure, + corsProxy, + url, + headers = {}, + forPush = false, + protocolVersion = 2, + prefix, + symrefs, + peelTags +}) { + try { + assertParameter("http", http); + assertParameter("url", url); + const remote = await GitRemoteHTTP.discover({ + http, + onAuth, + onAuthSuccess, + onAuthFailure, + corsProxy, + service: forPush ? "git-receive-pack" : "git-upload-pack", + url, + headers, + protocolVersion + }); + if (remote.protocolVersion === 1) { + return formatInfoRefs(remote, prefix, symrefs, peelTags); + } + const body = await writeListRefsRequest({ prefix, symrefs, peelTags }); + const res = await GitRemoteHTTP.connect({ + http, + auth: remote.auth, + headers, + corsProxy, + service: forPush ? "git-receive-pack" : "git-upload-pack", + url, + body + }); + return parseListRefsResponse(res.body); + } catch (err) { + err.caller = "git.listServerRefs"; + throw err; + } +} +async function listTags({ fs, dir, gitdir = join(dir, ".git") }) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + return GitRefManager.listTags({ fs: new FileSystem(fs), gitdir }); + } catch (err) { + err.caller = "git.listTags"; + throw err; + } +} +async function resolveCommit({ fs, cache, gitdir, oid }) { + const { type, object } = await _readObject({ fs, cache, gitdir, oid }); + if (type === "tag") { + oid = GitAnnotatedTag.from(object).parse().object; + return resolveCommit({ fs, cache, gitdir, oid }); + } + if (type !== "commit") { + throw new ObjectTypeError(oid, type, "commit"); + } + return { commit: GitCommit.from(object), oid }; +} +async function _readCommit({ fs, cache, gitdir, oid }) { + const { commit: commit2, oid: commitOid } = await resolveCommit({ + fs, + cache, + gitdir, + oid + }); + const result = { + oid: commitOid, + commit: commit2.parse(), + payload: commit2.withoutSignature() + }; + return result; +} +function compareAge(a, b) { + return a.committer.timestamp - b.committer.timestamp; +} +var EMPTY_OID = "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"; +async function resolveFileIdInTree({ fs, cache, gitdir, oid, fileId }) { + if (fileId === EMPTY_OID) + return; + const _oid = oid; + let filepath; + const result = await resolveTree({ fs, cache, gitdir, oid }); + const tree = result.tree; + if (fileId === result.oid) { + filepath = result.path; + } else { + filepath = await _resolveFileId({ + fs, + cache, + gitdir, + tree, + fileId, + oid: _oid + }); + if (Array.isArray(filepath)) { + if (filepath.length === 0) + filepath = void 0; + else if (filepath.length === 1) + filepath = filepath[0]; + } + } + return filepath; +} +async function _resolveFileId({ + fs, + cache, + gitdir, + tree, + fileId, + oid, + filepaths = [], + parentPath = "" +}) { + const walks = tree.entries().map(function(entry) { + let result; + if (entry.oid === fileId) { + result = join(parentPath, entry.path); + filepaths.push(result); + } else if (entry.type === "tree") { + result = _readObject({ + fs, + cache, + gitdir, + oid: entry.oid + }).then(function({ object }) { + return _resolveFileId({ + fs, + cache, + gitdir, + tree: GitTree.from(object), + fileId, + oid, + filepaths, + parentPath: join(parentPath, entry.path) + }); + }); + } + return result; + }); + await Promise.all(walks); + return filepaths; +} +async function _log({ + fs, + cache, + gitdir, + filepath, + ref, + depth, + since, + force, + follow +}) { + const sinceTimestamp = typeof since === "undefined" ? void 0 : Math.floor(since.valueOf() / 1e3); + const commits = []; + const shallowCommits = await GitShallowManager.read({ fs, gitdir }); + const oid = await GitRefManager.resolve({ fs, gitdir, ref }); + const tips = [await _readCommit({ fs, cache, gitdir, oid })]; + let lastFileOid; + let lastCommit; + let isOk; + function endCommit(commit2) { + if (isOk && filepath) + commits.push(commit2); + } + while (tips.length > 0) { + const commit2 = tips.pop(); + if (sinceTimestamp !== void 0 && commit2.commit.committer.timestamp <= sinceTimestamp) { + break; + } + if (filepath) { + let vFileOid; + try { + vFileOid = await resolveFilepath({ + fs, + cache, + gitdir, + oid: commit2.commit.tree, + filepath + }); + if (lastCommit && lastFileOid !== vFileOid) { + commits.push(lastCommit); + } + lastFileOid = vFileOid; + lastCommit = commit2; + isOk = true; + } catch (e) { + if (e instanceof NotFoundError) { + let found = follow && lastFileOid; + if (found) { + found = await resolveFileIdInTree({ + fs, + cache, + gitdir, + oid: commit2.commit.tree, + fileId: lastFileOid + }); + if (found) { + if (Array.isArray(found)) { + if (lastCommit) { + const lastFound = await resolveFileIdInTree({ + fs, + cache, + gitdir, + oid: lastCommit.commit.tree, + fileId: lastFileOid + }); + if (Array.isArray(lastFound)) { + found = found.filter((p) => lastFound.indexOf(p) === -1); + if (found.length === 1) { + found = found[0]; + filepath = found; + if (lastCommit) + commits.push(lastCommit); + } else { + found = false; + if (lastCommit) + commits.push(lastCommit); + break; + } + } + } + } else { + filepath = found; + if (lastCommit) + commits.push(lastCommit); + } + } + } + if (!found) { + if (isOk && lastFileOid) { + commits.push(lastCommit); + if (!force) + break; + } + if (!force && !follow) + throw e; + } + lastCommit = commit2; + isOk = false; + } else + throw e; + } + } else { + commits.push(commit2); + } + if (depth !== void 0 && commits.length === depth) { + endCommit(commit2); + break; + } + if (!shallowCommits.has(commit2.oid)) { + for (const oid2 of commit2.commit.parent) { + const commit3 = await _readCommit({ fs, cache, gitdir, oid: oid2 }); + if (!tips.map((commit4) => commit4.oid).includes(commit3.oid)) { + tips.push(commit3); + } + } + } + if (tips.length === 0) { + endCommit(commit2); + } + tips.sort((a, b) => compareAge(a.commit, b.commit)); + } + return commits; +} +async function log({ + fs, + dir, + gitdir = join(dir, ".git"), + filepath, + ref = "HEAD", + depth, + since, + // Date + force, + follow, + cache = {} +}) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + assertParameter("ref", ref); + return await _log({ + fs: new FileSystem(fs), + cache, + gitdir, + filepath, + ref, + depth, + since, + force, + follow + }); + } catch (err) { + err.caller = "git.log"; + throw err; + } +} +async function merge({ + fs: _fs, + onSign, + dir, + gitdir = join(dir, ".git"), + ours, + theirs, + fastForward: fastForward2 = true, + fastForwardOnly = false, + dryRun = false, + noUpdateBranch = false, + abortOnConflict = true, + message, + author: _author, + committer: _committer, + signingKey, + cache = {}, + mergeDriver +}) { + try { + assertParameter("fs", _fs); + if (signingKey) { + assertParameter("onSign", onSign); + } + const fs = new FileSystem(_fs); + const author = await normalizeAuthorObject({ fs, gitdir, author: _author }); + if (!author && (!fastForwardOnly || !fastForward2)) { + throw new MissingNameError("author"); + } + const committer = await normalizeCommitterObject({ + fs, + gitdir, + author, + committer: _committer + }); + if (!committer && (!fastForwardOnly || !fastForward2)) { + throw new MissingNameError("committer"); + } + return await _merge({ + fs, + cache, + dir, + gitdir, + ours, + theirs, + fastForward: fastForward2, + fastForwardOnly, + dryRun, + noUpdateBranch, + abortOnConflict, + message, + author, + committer, + signingKey, + onSign, + mergeDriver + }); + } catch (err) { + err.caller = "git.merge"; + throw err; + } +} +var types = { + commit: 16, + tree: 32, + blob: 48, + tag: 64, + ofs_delta: 96, + ref_delta: 112 +}; +async function _pack({ + fs, + cache, + dir, + gitdir = join(dir, ".git"), + oids +}) { + const hash2 = new import_sha1.default(); + const outputStream = []; + function write(chunk, enc) { + const buff = Buffer.from(chunk, enc); + outputStream.push(buff); + hash2.update(buff); + } + async function writeObject2({ stype, object }) { + const type = types[stype]; + let length = object.length; + let multibyte = length > 15 ? 128 : 0; + const lastFour = length & 15; + length = length >>> 4; + let byte = (multibyte | type | lastFour).toString(16); + write(byte, "hex"); + while (multibyte) { + multibyte = length > 127 ? 128 : 0; + byte = multibyte | length & 127; + write(padHex(2, byte), "hex"); + length = length >>> 7; + } + write(Buffer.from(await deflate(object))); + } + write("PACK"); + write("00000002", "hex"); + write(padHex(8, oids.length), "hex"); + for (const oid of oids) { + const { type, object } = await _readObject({ fs, cache, gitdir, oid }); + await writeObject2({ write, object, stype: type }); + } + const digest = hash2.digest(); + outputStream.push(digest); + return outputStream; +} +async function _packObjects({ fs, cache, gitdir, oids, write }) { + const buffers = await _pack({ fs, cache, gitdir, oids }); + const packfile = Buffer.from(await collect(buffers)); + const packfileSha = packfile.slice(-20).toString("hex"); + const filename = `pack-${packfileSha}.pack`; + if (write) { + await fs.write(join(gitdir, `objects/pack/${filename}`), packfile); + return { filename }; + } + return { + filename, + packfile: new Uint8Array(packfile) + }; +} +async function packObjects({ + fs, + dir, + gitdir = join(dir, ".git"), + oids, + write = false, + cache = {} +}) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + assertParameter("oids", oids); + return await _packObjects({ + fs: new FileSystem(fs), + cache, + gitdir, + oids, + write + }); + } catch (err) { + err.caller = "git.packObjects"; + throw err; + } +} +async function pull({ + fs: _fs, + http, + onProgress, + onMessage, + onAuth, + onAuthSuccess, + onAuthFailure, + dir, + gitdir = join(dir, ".git"), + ref, + url, + remote, + remoteRef, + prune = false, + pruneTags = false, + fastForward: fastForward2 = true, + fastForwardOnly = false, + corsProxy, + singleBranch, + headers = {}, + author: _author, + committer: _committer, + signingKey, + cache = {} +}) { + try { + assertParameter("fs", _fs); + assertParameter("gitdir", gitdir); + const fs = new FileSystem(_fs); + const author = await normalizeAuthorObject({ fs, gitdir, author: _author }); + if (!author) + throw new MissingNameError("author"); + const committer = await normalizeCommitterObject({ + fs, + gitdir, + author, + committer: _committer + }); + if (!committer) + throw new MissingNameError("committer"); + return await _pull({ + fs, + cache, + http, + onProgress, + onMessage, + onAuth, + onAuthSuccess, + onAuthFailure, + dir, + gitdir, + ref, + url, + remote, + remoteRef, + fastForward: fastForward2, + fastForwardOnly, + corsProxy, + singleBranch, + headers, + author, + committer, + signingKey, + prune, + pruneTags + }); + } catch (err) { + err.caller = "git.pull"; + throw err; + } +} +async function listCommitsAndTags({ + fs, + cache, + dir, + gitdir = join(dir, ".git"), + start, + finish +}) { + const shallows = await GitShallowManager.read({ fs, gitdir }); + const startingSet = /* @__PURE__ */ new Set(); + const finishingSet = /* @__PURE__ */ new Set(); + for (const ref of start) { + startingSet.add(await GitRefManager.resolve({ fs, gitdir, ref })); + } + for (const ref of finish) { + try { + const oid = await GitRefManager.resolve({ fs, gitdir, ref }); + finishingSet.add(oid); + } catch (err) { + } + } + const visited = /* @__PURE__ */ new Set(); + async function walk2(oid) { + visited.add(oid); + const { type, object } = await _readObject({ fs, cache, gitdir, oid }); + if (type === "tag") { + const tag2 = GitAnnotatedTag.from(object); + const commit2 = tag2.headers().object; + return walk2(commit2); + } + if (type !== "commit") { + throw new ObjectTypeError(oid, type, "commit"); + } + if (!shallows.has(oid)) { + const commit2 = GitCommit.from(object); + const parents = commit2.headers().parent; + for (oid of parents) { + if (!finishingSet.has(oid) && !visited.has(oid)) { + await walk2(oid); + } + } + } + } + for (const oid of startingSet) { + await walk2(oid); + } + return visited; +} +async function listObjects({ + fs, + cache, + dir, + gitdir = join(dir, ".git"), + oids +}) { + const visited = /* @__PURE__ */ new Set(); + async function walk2(oid) { + if (visited.has(oid)) + return; + visited.add(oid); + const { type, object } = await _readObject({ fs, cache, gitdir, oid }); + if (type === "tag") { + const tag2 = GitAnnotatedTag.from(object); + const obj = tag2.headers().object; + await walk2(obj); + } else if (type === "commit") { + const commit2 = GitCommit.from(object); + const tree = commit2.headers().tree; + await walk2(tree); + } else if (type === "tree") { + const tree = GitTree.from(object); + for (const entry of tree) { + if (entry.type === "blob") { + visited.add(entry.oid); + } + if (entry.type === "tree") { + await walk2(entry.oid); + } + } + } + } + for (const oid of oids) { + await walk2(oid); + } + return visited; +} +async function parseReceivePackResponse(packfile) { + const result = {}; + let response = ""; + const read = GitPktLine.streamReader(packfile); + let line = await read(); + while (line !== true) { + if (line !== null) + response += line.toString("utf8") + "\n"; + line = await read(); + } + const lines = response.toString("utf8").split("\n"); + line = lines.shift(); + if (!line.startsWith("unpack ")) { + throw new ParseError('unpack ok" or "unpack [error message]', line); + } + result.ok = line === "unpack ok"; + if (!result.ok) { + result.error = line.slice("unpack ".length); + } + result.refs = {}; + for (const line2 of lines) { + if (line2.trim() === "") + continue; + const status2 = line2.slice(0, 2); + const refAndMessage = line2.slice(3); + let space2 = refAndMessage.indexOf(" "); + if (space2 === -1) + space2 = refAndMessage.length; + const ref = refAndMessage.slice(0, space2); + const error = refAndMessage.slice(space2 + 1); + result.refs[ref] = { + ok: status2 === "ok", + error + }; + } + return result; +} +async function writeReceivePackRequest({ + capabilities = [], + triplets = [] +}) { + const packstream = []; + let capsFirstLine = `\0 ${capabilities.join(" ")}`; + for (const trip of triplets) { + packstream.push( + GitPktLine.encode( + `${trip.oldoid} ${trip.oid} ${trip.fullRef}${capsFirstLine} +` + ) + ); + capsFirstLine = ""; + } + packstream.push(GitPktLine.flush()); + return packstream; +} +async function _push({ + fs, + cache, + http, + onProgress, + onMessage, + onAuth, + onAuthSuccess, + onAuthFailure, + gitdir, + ref: _ref, + remoteRef: _remoteRef, + remote, + url: _url, + force = false, + delete: _delete = false, + corsProxy, + headers = {} +}) { + const ref = _ref || await _currentBranch({ fs, gitdir }); + if (typeof ref === "undefined") { + throw new MissingParameterError("ref"); + } + const config = await GitConfigManager.get({ fs, gitdir }); + remote = remote || await config.get(`branch.${ref}.pushRemote`) || await config.get("remote.pushDefault") || await config.get(`branch.${ref}.remote`) || "origin"; + const url = _url || await config.get(`remote.${remote}.pushurl`) || await config.get(`remote.${remote}.url`); + if (typeof url === "undefined") { + throw new MissingParameterError("remote OR url"); + } + const remoteRef = _remoteRef || await config.get(`branch.${ref}.merge`); + if (typeof url === "undefined") { + throw new MissingParameterError("remoteRef"); + } + if (corsProxy === void 0) { + corsProxy = await config.get("http.corsProxy"); + } + const fullRef = await GitRefManager.expand({ fs, gitdir, ref }); + const oid = _delete ? "0000000000000000000000000000000000000000" : await GitRefManager.resolve({ fs, gitdir, ref: fullRef }); + const GitRemoteHTTP2 = GitRemoteManager.getRemoteHelperFor({ url }); + const httpRemote = await GitRemoteHTTP2.discover({ + http, + onAuth, + onAuthSuccess, + onAuthFailure, + corsProxy, + service: "git-receive-pack", + url, + headers, + protocolVersion: 1 + }); + const auth = httpRemote.auth; + let fullRemoteRef; + if (!remoteRef) { + fullRemoteRef = fullRef; + } else { + try { + fullRemoteRef = await GitRefManager.expandAgainstMap({ + ref: remoteRef, + map: httpRemote.refs + }); + } catch (err) { + if (err instanceof NotFoundError) { + fullRemoteRef = remoteRef.startsWith("refs/") ? remoteRef : `refs/heads/${remoteRef}`; + } else { + throw err; + } + } + } + const oldoid = httpRemote.refs.get(fullRemoteRef) || "0000000000000000000000000000000000000000"; + const thinPack = !httpRemote.capabilities.has("no-thin"); + let objects = /* @__PURE__ */ new Set(); + if (!_delete) { + const finish = [...httpRemote.refs.values()]; + let skipObjects = /* @__PURE__ */ new Set(); + if (oldoid !== "0000000000000000000000000000000000000000") { + const mergebase = await _findMergeBase({ + fs, + cache, + gitdir, + oids: [oid, oldoid] + }); + for (const oid2 of mergebase) + finish.push(oid2); + if (thinPack) { + skipObjects = await listObjects({ fs, cache, gitdir, oids: mergebase }); + } + } + if (!finish.includes(oid)) { + const commits = await listCommitsAndTags({ + fs, + cache, + gitdir, + start: [oid], + finish + }); + objects = await listObjects({ fs, cache, gitdir, oids: commits }); + } + if (thinPack) { + try { + const ref2 = await GitRefManager.resolve({ + fs, + gitdir, + ref: `refs/remotes/${remote}/HEAD`, + depth: 2 + }); + const { oid: oid2 } = await GitRefManager.resolveAgainstMap({ + ref: ref2.replace(`refs/remotes/${remote}/`, ""), + fullref: ref2, + map: httpRemote.refs + }); + const oids = [oid2]; + for (const oid3 of await listObjects({ fs, cache, gitdir, oids })) { + skipObjects.add(oid3); + } + } catch (e) { + } + for (const oid2 of skipObjects) { + objects.delete(oid2); + } + } + if (oid === oldoid) + force = true; + if (!force) { + if (fullRef.startsWith("refs/tags") && oldoid !== "0000000000000000000000000000000000000000") { + throw new PushRejectedError("tag-exists"); + } + if (oid !== "0000000000000000000000000000000000000000" && oldoid !== "0000000000000000000000000000000000000000" && !await _isDescendent({ + fs, + cache, + gitdir, + oid, + ancestor: oldoid, + depth: -1 + })) { + throw new PushRejectedError("not-fast-forward"); + } + } + } + const capabilities = filterCapabilities( + [...httpRemote.capabilities], + ["report-status", "side-band-64k", `agent=${pkg.agent}`] + ); + const packstream1 = await writeReceivePackRequest({ + capabilities, + triplets: [{ oldoid, oid, fullRef: fullRemoteRef }] + }); + const packstream2 = _delete ? [] : await _pack({ + fs, + cache, + gitdir, + oids: [...objects] + }); + const res = await GitRemoteHTTP2.connect({ + http, + onProgress, + corsProxy, + service: "git-receive-pack", + url, + auth, + headers, + body: [...packstream1, ...packstream2] + }); + const { packfile, progress } = await GitSideBand.demux(res.body); + if (onMessage) { + const lines = splitLines(progress); + forAwait(lines, async (line) => { + await onMessage(line); + }); + } + const result = await parseReceivePackResponse(packfile); + if (res.headers) { + result.headers = res.headers; + } + if (remote && result.ok && result.refs[fullRemoteRef].ok) { + const ref2 = `refs/remotes/${remote}/${fullRemoteRef.replace( + "refs/heads", + "" + )}`; + if (_delete) { + await GitRefManager.deleteRef({ fs, gitdir, ref: ref2 }); + } else { + await GitRefManager.writeRef({ fs, gitdir, ref: ref2, value: oid }); + } + } + if (result.ok && Object.values(result.refs).every((result2) => result2.ok)) { + return result; + } else { + const prettyDetails = Object.entries(result.refs).filter(([k, v]) => !v.ok).map(([k, v]) => ` + - ${k}: ${v.error}`).join(""); + throw new GitPushError(prettyDetails, result); + } +} +async function push({ + fs, + http, + onProgress, + onMessage, + onAuth, + onAuthSuccess, + onAuthFailure, + dir, + gitdir = join(dir, ".git"), + ref, + remoteRef, + remote = "origin", + url, + force = false, + delete: _delete = false, + corsProxy, + headers = {}, + cache = {} +}) { + try { + assertParameter("fs", fs); + assertParameter("http", http); + assertParameter("gitdir", gitdir); + return await _push({ + fs: new FileSystem(fs), + cache, + http, + onProgress, + onMessage, + onAuth, + onAuthSuccess, + onAuthFailure, + gitdir, + ref, + remoteRef, + remote, + url, + force, + delete: _delete, + corsProxy, + headers + }); + } catch (err) { + err.caller = "git.push"; + throw err; + } +} +async function resolveBlob({ fs, cache, gitdir, oid }) { + const { type, object } = await _readObject({ fs, cache, gitdir, oid }); + if (type === "tag") { + oid = GitAnnotatedTag.from(object).parse().object; + return resolveBlob({ fs, cache, gitdir, oid }); + } + if (type !== "blob") { + throw new ObjectTypeError(oid, type, "blob"); + } + return { oid, blob: new Uint8Array(object) }; +} +async function _readBlob({ + fs, + cache, + gitdir, + oid, + filepath = void 0 +}) { + if (filepath !== void 0) { + oid = await resolveFilepath({ fs, cache, gitdir, oid, filepath }); + } + const blob = await resolveBlob({ + fs, + cache, + gitdir, + oid + }); + return blob; +} +async function readBlob({ + fs, + dir, + gitdir = join(dir, ".git"), + oid, + filepath, + cache = {} +}) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + assertParameter("oid", oid); + return await _readBlob({ + fs: new FileSystem(fs), + cache, + gitdir, + oid, + filepath + }); + } catch (err) { + err.caller = "git.readBlob"; + throw err; + } +} +async function readCommit({ + fs, + dir, + gitdir = join(dir, ".git"), + oid, + cache = {} +}) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + assertParameter("oid", oid); + return await _readCommit({ + fs: new FileSystem(fs), + cache, + gitdir, + oid + }); + } catch (err) { + err.caller = "git.readCommit"; + throw err; + } +} +async function _readNote({ + fs, + cache, + gitdir, + ref = "refs/notes/commits", + oid +}) { + const parent = await GitRefManager.resolve({ gitdir, fs, ref }); + const { blob } = await _readBlob({ + fs, + cache, + gitdir, + oid: parent, + filepath: oid + }); + return blob; +} +async function readNote({ + fs, + dir, + gitdir = join(dir, ".git"), + ref = "refs/notes/commits", + oid, + cache = {} +}) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + assertParameter("ref", ref); + assertParameter("oid", oid); + return await _readNote({ + fs: new FileSystem(fs), + cache, + gitdir, + ref, + oid + }); + } catch (err) { + err.caller = "git.readNote"; + throw err; + } +} +async function readObject({ + fs: _fs, + dir, + gitdir = join(dir, ".git"), + oid, + format = "parsed", + filepath = void 0, + encoding = void 0, + cache = {} +}) { + try { + assertParameter("fs", _fs); + assertParameter("gitdir", gitdir); + assertParameter("oid", oid); + const fs = new FileSystem(_fs); + if (filepath !== void 0) { + oid = await resolveFilepath({ + fs, + cache, + gitdir, + oid, + filepath + }); + } + const _format = format === "parsed" ? "content" : format; + const result = await _readObject({ + fs, + cache, + gitdir, + oid, + format: _format + }); + result.oid = oid; + if (format === "parsed") { + result.format = "parsed"; + switch (result.type) { + case "commit": + result.object = GitCommit.from(result.object).parse(); + break; + case "tree": + result.object = GitTree.from(result.object).entries(); + break; + case "blob": + if (encoding) { + result.object = result.object.toString(encoding); + } else { + result.object = new Uint8Array(result.object); + result.format = "content"; + } + break; + case "tag": + result.object = GitAnnotatedTag.from(result.object).parse(); + break; + default: + throw new ObjectTypeError( + result.oid, + result.type, + "blob|commit|tag|tree" + ); + } + } else if (result.format === "deflated" || result.format === "wrapped") { + result.type = result.format; + } + return result; + } catch (err) { + err.caller = "git.readObject"; + throw err; + } +} +async function _readTag({ fs, cache, gitdir, oid }) { + const { type, object } = await _readObject({ + fs, + cache, + gitdir, + oid, + format: "content" + }); + if (type !== "tag") { + throw new ObjectTypeError(oid, type, "tag"); + } + const tag2 = GitAnnotatedTag.from(object); + const result = { + oid, + tag: tag2.parse(), + payload: tag2.payload() + }; + return result; +} +async function readTag({ + fs, + dir, + gitdir = join(dir, ".git"), + oid, + cache = {} +}) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + assertParameter("oid", oid); + return await _readTag({ + fs: new FileSystem(fs), + cache, + gitdir, + oid + }); + } catch (err) { + err.caller = "git.readTag"; + throw err; + } +} +async function readTree({ + fs, + dir, + gitdir = join(dir, ".git"), + oid, + filepath = void 0, + cache = {} +}) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + assertParameter("oid", oid); + return await _readTree({ + fs: new FileSystem(fs), + cache, + gitdir, + oid, + filepath + }); + } catch (err) { + err.caller = "git.readTree"; + throw err; + } +} +async function remove({ + fs: _fs, + dir, + gitdir = join(dir, ".git"), + filepath, + cache = {} +}) { + try { + assertParameter("fs", _fs); + assertParameter("gitdir", gitdir); + assertParameter("filepath", filepath); + await GitIndexManager.acquire( + { fs: new FileSystem(_fs), gitdir, cache }, + async function(index2) { + index2.delete({ filepath }); + } + ); + } catch (err) { + err.caller = "git.remove"; + throw err; + } +} +async function _removeNote({ + fs, + cache, + onSign, + gitdir, + ref = "refs/notes/commits", + oid, + author, + committer, + signingKey +}) { + let parent; + try { + parent = await GitRefManager.resolve({ gitdir, fs, ref }); + } catch (err) { + if (!(err instanceof NotFoundError)) { + throw err; + } + } + const result = await _readTree({ + fs, + gitdir, + oid: parent || "4b825dc642cb6eb9a060e54bf8d69288fbee4904" + }); + let tree = result.tree; + tree = tree.filter((entry) => entry.path !== oid); + const treeOid = await _writeTree({ + fs, + gitdir, + tree + }); + const commitOid = await _commit({ + fs, + cache, + onSign, + gitdir, + ref, + tree: treeOid, + parent: parent && [parent], + message: `Note removed by 'isomorphic-git removeNote' +`, + author, + committer, + signingKey + }); + return commitOid; +} +async function removeNote({ + fs: _fs, + onSign, + dir, + gitdir = join(dir, ".git"), + ref = "refs/notes/commits", + oid, + author: _author, + committer: _committer, + signingKey, + cache = {} +}) { + try { + assertParameter("fs", _fs); + assertParameter("gitdir", gitdir); + assertParameter("oid", oid); + const fs = new FileSystem(_fs); + const author = await normalizeAuthorObject({ fs, gitdir, author: _author }); + if (!author) + throw new MissingNameError("author"); + const committer = await normalizeCommitterObject({ + fs, + gitdir, + author, + committer: _committer + }); + if (!committer) + throw new MissingNameError("committer"); + return await _removeNote({ + fs, + cache, + onSign, + gitdir, + ref, + oid, + author, + committer, + signingKey + }); + } catch (err) { + err.caller = "git.removeNote"; + throw err; + } +} +async function _renameBranch({ + fs, + gitdir, + oldref, + ref, + checkout: checkout2 = false +}) { + if (ref !== import_clean_git_ref.default.clean(ref)) { + throw new InvalidRefNameError(ref, import_clean_git_ref.default.clean(ref)); + } + if (oldref !== import_clean_git_ref.default.clean(oldref)) { + throw new InvalidRefNameError(oldref, import_clean_git_ref.default.clean(oldref)); + } + const fulloldref = `refs/heads/${oldref}`; + const fullnewref = `refs/heads/${ref}`; + const newexist = await GitRefManager.exists({ fs, gitdir, ref: fullnewref }); + if (newexist) { + throw new AlreadyExistsError("branch", ref, false); + } + const value = await GitRefManager.resolve({ + fs, + gitdir, + ref: fulloldref, + depth: 1 + }); + await GitRefManager.writeRef({ fs, gitdir, ref: fullnewref, value }); + await GitRefManager.deleteRef({ fs, gitdir, ref: fulloldref }); + if (checkout2) { + await GitRefManager.writeSymbolicRef({ + fs, + gitdir, + ref: "HEAD", + value: fullnewref + }); + } +} +async function renameBranch({ + fs, + dir, + gitdir = join(dir, ".git"), + ref, + oldref, + checkout: checkout2 = false +}) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + assertParameter("ref", ref); + assertParameter("oldref", oldref); + return await _renameBranch({ + fs: new FileSystem(fs), + gitdir, + ref, + oldref, + checkout: checkout2 + }); + } catch (err) { + err.caller = "git.renameBranch"; + throw err; + } +} +async function hashObject$1({ gitdir, type, object }) { + return shasum(GitObject.wrap({ type, object })); +} +async function resetIndex({ + fs: _fs, + dir, + gitdir = join(dir, ".git"), + filepath, + ref, + cache = {} +}) { + try { + assertParameter("fs", _fs); + assertParameter("gitdir", gitdir); + assertParameter("filepath", filepath); + const fs = new FileSystem(_fs); + let oid; + let workdirOid; + try { + oid = await GitRefManager.resolve({ fs, gitdir, ref: ref || "HEAD" }); + } catch (e) { + if (ref) { + throw e; + } + } + if (oid) { + try { + oid = await resolveFilepath({ + fs, + cache, + gitdir, + oid, + filepath + }); + } catch (e) { + oid = null; + } + } + let stats = { + ctime: /* @__PURE__ */ new Date(0), + mtime: /* @__PURE__ */ new Date(0), + dev: 0, + ino: 0, + mode: 0, + uid: 0, + gid: 0, + size: 0 + }; + const object = dir && await fs.read(join(dir, filepath)); + if (object) { + workdirOid = await hashObject$1({ + gitdir, + type: "blob", + object + }); + if (oid === workdirOid) { + stats = await fs.lstat(join(dir, filepath)); + } + } + await GitIndexManager.acquire({ fs, gitdir, cache }, async function(index2) { + index2.delete({ filepath }); + if (oid) { + index2.insert({ filepath, stats, oid }); + } + }); + } catch (err) { + err.caller = "git.reset"; + throw err; + } +} +async function resolveRef({ + fs, + dir, + gitdir = join(dir, ".git"), + ref, + depth +}) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + assertParameter("ref", ref); + const oid = await GitRefManager.resolve({ + fs: new FileSystem(fs), + gitdir, + ref, + depth + }); + return oid; + } catch (err) { + err.caller = "git.resolveRef"; + throw err; + } +} +async function setConfig({ + fs: _fs, + dir, + gitdir = join(dir, ".git"), + path: path2, + value, + append: append3 = false +}) { + try { + assertParameter("fs", _fs); + assertParameter("gitdir", gitdir); + assertParameter("path", path2); + const fs = new FileSystem(_fs); + const config = await GitConfigManager.get({ fs, gitdir }); + if (append3) { + await config.append(path2, value); + } else { + await config.set(path2, value); + } + await GitConfigManager.save({ fs, gitdir, config }); + } catch (err) { + err.caller = "git.setConfig"; + throw err; + } +} +async function status({ + fs: _fs, + dir, + gitdir = join(dir, ".git"), + filepath, + cache = {} +}) { + try { + assertParameter("fs", _fs); + assertParameter("gitdir", gitdir); + assertParameter("filepath", filepath); + const fs = new FileSystem(_fs); + const ignored = await GitIgnoreManager.isIgnored({ + fs, + gitdir, + dir, + filepath + }); + if (ignored) { + return "ignored"; + } + const headTree = await getHeadTree({ fs, cache, gitdir }); + const treeOid = await getOidAtPath({ + fs, + cache, + gitdir, + tree: headTree, + path: filepath + }); + const indexEntry = await GitIndexManager.acquire( + { fs, gitdir, cache }, + async function(index2) { + for (const entry of index2) { + if (entry.path === filepath) + return entry; + } + return null; + } + ); + const stats = await fs.lstat(join(dir, filepath)); + const H = treeOid !== null; + const I = indexEntry !== null; + const W = stats !== null; + const getWorkdirOid = async () => { + if (I && !compareStats(indexEntry, stats)) { + return indexEntry.oid; + } else { + const object = await fs.read(join(dir, filepath)); + const workdirOid = await hashObject$1({ + gitdir, + type: "blob", + object + }); + if (I && indexEntry.oid === workdirOid) { + if (stats.size !== -1) { + GitIndexManager.acquire({ fs, gitdir, cache }, async function(index2) { + index2.insert({ filepath, stats, oid: workdirOid }); + }); + } + } + return workdirOid; + } + }; + if (!H && !W && !I) + return "absent"; + if (!H && !W && I) + return "*absent"; + if (!H && W && !I) + return "*added"; + if (!H && W && I) { + const workdirOid = await getWorkdirOid(); + return workdirOid === indexEntry.oid ? "added" : "*added"; + } + if (H && !W && !I) + return "deleted"; + if (H && !W && I) { + return treeOid === indexEntry.oid ? "*deleted" : "*deleted"; + } + if (H && W && !I) { + const workdirOid = await getWorkdirOid(); + return workdirOid === treeOid ? "*undeleted" : "*undeletemodified"; + } + if (H && W && I) { + const workdirOid = await getWorkdirOid(); + if (workdirOid === treeOid) { + return workdirOid === indexEntry.oid ? "unmodified" : "*unmodified"; + } else { + return workdirOid === indexEntry.oid ? "modified" : "*modified"; + } + } + } catch (err) { + err.caller = "git.status"; + throw err; + } +} +async function getOidAtPath({ fs, cache, gitdir, tree, path: path2 }) { + if (typeof path2 === "string") + path2 = path2.split("/"); + const dirname3 = path2.shift(); + for (const entry of tree) { + if (entry.path === dirname3) { + if (path2.length === 0) { + return entry.oid; + } + const { type, object } = await _readObject({ + fs, + cache, + gitdir, + oid: entry.oid + }); + if (type === "tree") { + const tree2 = GitTree.from(object); + return getOidAtPath({ fs, cache, gitdir, tree: tree2, path: path2 }); + } + if (type === "blob") { + throw new ObjectTypeError(entry.oid, type, "blob", path2.join("/")); + } + } + } + return null; +} +async function getHeadTree({ fs, cache, gitdir }) { + let oid; + try { + oid = await GitRefManager.resolve({ fs, gitdir, ref: "HEAD" }); + } catch (e) { + if (e instanceof NotFoundError) { + return []; + } + } + const { tree } = await _readTree({ fs, cache, gitdir, oid }); + return tree; +} +async function statusMatrix({ + fs: _fs, + dir, + gitdir = join(dir, ".git"), + ref = "HEAD", + filepaths = ["."], + filter, + cache = {}, + ignored: shouldIgnore = false +}) { + try { + assertParameter("fs", _fs); + assertParameter("gitdir", gitdir); + assertParameter("ref", ref); + const fs = new FileSystem(_fs); + return await _walk({ + fs, + cache, + dir, + gitdir, + trees: [TREE({ ref }), WORKDIR(), STAGE()], + map: async function(filepath, [head, workdir, stage]) { + if (!head && !stage && workdir) { + if (!shouldIgnore) { + const isIgnored2 = await GitIgnoreManager.isIgnored({ + fs, + dir, + filepath + }); + if (isIgnored2) { + return null; + } + } + } + if (!filepaths.some((base) => worthWalking(filepath, base))) { + return null; + } + if (filter) { + if (!filter(filepath)) + return; + } + const [headType, workdirType, stageType] = await Promise.all([ + head && head.type(), + workdir && workdir.type(), + stage && stage.type() + ]); + const isBlob = [headType, workdirType, stageType].includes("blob"); + if ((headType === "tree" || headType === "special") && !isBlob) + return; + if (headType === "commit") + return null; + if ((workdirType === "tree" || workdirType === "special") && !isBlob) + return; + if (stageType === "commit") + return null; + if ((stageType === "tree" || stageType === "special") && !isBlob) + return; + const headOid = headType === "blob" ? await head.oid() : void 0; + const stageOid = stageType === "blob" ? await stage.oid() : void 0; + let workdirOid; + if (headType !== "blob" && workdirType === "blob" && stageType !== "blob") { + workdirOid = "42"; + } else if (workdirType === "blob") { + workdirOid = await workdir.oid(); + } + const entry = [void 0, headOid, workdirOid, stageOid]; + const result = entry.map((value) => entry.indexOf(value)); + result.shift(); + return [filepath, ...result]; + } + }); + } catch (err) { + err.caller = "git.statusMatrix"; + throw err; + } +} +async function tag({ + fs: _fs, + dir, + gitdir = join(dir, ".git"), + ref, + object, + force = false +}) { + try { + assertParameter("fs", _fs); + assertParameter("gitdir", gitdir); + assertParameter("ref", ref); + const fs = new FileSystem(_fs); + if (ref === void 0) { + throw new MissingParameterError("ref"); + } + ref = ref.startsWith("refs/tags/") ? ref : `refs/tags/${ref}`; + const value = await GitRefManager.resolve({ + fs, + gitdir, + ref: object || "HEAD" + }); + if (!force && await GitRefManager.exists({ fs, gitdir, ref })) { + throw new AlreadyExistsError("tag", ref); + } + await GitRefManager.writeRef({ fs, gitdir, ref, value }); + } catch (err) { + err.caller = "git.tag"; + throw err; + } +} +async function updateIndex({ + fs: _fs, + dir, + gitdir = join(dir, ".git"), + cache = {}, + filepath, + oid, + mode, + add: add2, + remove: remove3, + force +}) { + try { + assertParameter("fs", _fs); + assertParameter("gitdir", gitdir); + assertParameter("filepath", filepath); + const fs = new FileSystem(_fs); + if (remove3) { + return await GitIndexManager.acquire( + { fs, gitdir, cache }, + async function(index2) { + let fileStats2; + if (!force) { + fileStats2 = await fs.lstat(join(dir, filepath)); + if (fileStats2) { + if (fileStats2.isDirectory()) { + throw new InvalidFilepathError("directory"); + } + return; + } + } + if (index2.has({ filepath })) { + index2.delete({ + filepath + }); + } + } + ); + } + let fileStats; + if (!oid) { + fileStats = await fs.lstat(join(dir, filepath)); + if (!fileStats) { + throw new NotFoundError( + `file at "${filepath}" on disk and "remove" not set` + ); + } + if (fileStats.isDirectory()) { + throw new InvalidFilepathError("directory"); + } + } + return await GitIndexManager.acquire({ fs, gitdir, cache }, async function(index2) { + if (!add2 && !index2.has({ filepath })) { + throw new NotFoundError( + `file at "${filepath}" in index and "add" not set` + ); + } + let stats = { + ctime: /* @__PURE__ */ new Date(0), + mtime: /* @__PURE__ */ new Date(0), + dev: 0, + ino: 0, + mode, + uid: 0, + gid: 0, + size: 0 + }; + if (!oid) { + stats = fileStats; + const object = stats.isSymbolicLink() ? await fs.readlink(join(dir, filepath)) : await fs.read(join(dir, filepath)); + oid = await _writeObject({ + fs, + gitdir, + type: "blob", + format: "content", + object + }); + } + index2.insert({ + filepath, + oid, + stats + }); + return oid; + }); + } catch (err) { + err.caller = "git.updateIndex"; + throw err; + } +} +function version() { + try { + return pkg.version; + } catch (err) { + err.caller = "git.version"; + throw err; + } +} +async function walk({ + fs, + dir, + gitdir = join(dir, ".git"), + trees, + map, + reduce, + iterate, + cache = {} +}) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + assertParameter("trees", trees); + return await _walk({ + fs: new FileSystem(fs), + cache, + dir, + gitdir, + trees, + map, + reduce, + iterate + }); + } catch (err) { + err.caller = "git.walk"; + throw err; + } +} +async function writeBlob({ fs, dir, gitdir = join(dir, ".git"), blob }) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + assertParameter("blob", blob); + return await _writeObject({ + fs: new FileSystem(fs), + gitdir, + type: "blob", + object: blob, + format: "content" + }); + } catch (err) { + err.caller = "git.writeBlob"; + throw err; + } +} +async function _writeCommit({ fs, gitdir, commit: commit2 }) { + const object = GitCommit.from(commit2).toObject(); + const oid = await _writeObject({ + fs, + gitdir, + type: "commit", + object, + format: "content" + }); + return oid; +} +async function writeCommit({ + fs, + dir, + gitdir = join(dir, ".git"), + commit: commit2 +}) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + assertParameter("commit", commit2); + return await _writeCommit({ + fs: new FileSystem(fs), + gitdir, + commit: commit2 + }); + } catch (err) { + err.caller = "git.writeCommit"; + throw err; + } +} +async function writeObject({ + fs: _fs, + dir, + gitdir = join(dir, ".git"), + type, + object, + format = "parsed", + oid, + encoding = void 0 +}) { + try { + const fs = new FileSystem(_fs); + if (format === "parsed") { + switch (type) { + case "commit": + object = GitCommit.from(object).toObject(); + break; + case "tree": + object = GitTree.from(object).toObject(); + break; + case "blob": + object = Buffer.from(object, encoding); + break; + case "tag": + object = GitAnnotatedTag.from(object).toObject(); + break; + default: + throw new ObjectTypeError(oid || "", type, "blob|commit|tag|tree"); + } + format = "content"; + } + oid = await _writeObject({ + fs, + gitdir, + type, + object, + oid, + format + }); + return oid; + } catch (err) { + err.caller = "git.writeObject"; + throw err; + } +} +async function writeRef({ + fs: _fs, + dir, + gitdir = join(dir, ".git"), + ref, + value, + force = false, + symbolic = false +}) { + try { + assertParameter("fs", _fs); + assertParameter("gitdir", gitdir); + assertParameter("ref", ref); + assertParameter("value", value); + const fs = new FileSystem(_fs); + if (ref !== import_clean_git_ref.default.clean(ref)) { + throw new InvalidRefNameError(ref, import_clean_git_ref.default.clean(ref)); + } + if (!force && await GitRefManager.exists({ fs, gitdir, ref })) { + throw new AlreadyExistsError("ref", ref); + } + if (symbolic) { + await GitRefManager.writeSymbolicRef({ + fs, + gitdir, + ref, + value + }); + } else { + value = await GitRefManager.resolve({ + fs, + gitdir, + ref: value + }); + await GitRefManager.writeRef({ + fs, + gitdir, + ref, + value + }); + } + } catch (err) { + err.caller = "git.writeRef"; + throw err; + } +} +async function _writeTag({ fs, gitdir, tag: tag2 }) { + const object = GitAnnotatedTag.from(tag2).toObject(); + const oid = await _writeObject({ + fs, + gitdir, + type: "tag", + object, + format: "content" + }); + return oid; +} +async function writeTag({ fs, dir, gitdir = join(dir, ".git"), tag: tag2 }) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + assertParameter("tag", tag2); + return await _writeTag({ + fs: new FileSystem(fs), + gitdir, + tag: tag2 + }); + } catch (err) { + err.caller = "git.writeTag"; + throw err; + } +} +async function writeTree({ fs, dir, gitdir = join(dir, ".git"), tree }) { + try { + assertParameter("fs", fs); + assertParameter("gitdir", gitdir); + assertParameter("tree", tree); + return await _writeTree({ + fs: new FileSystem(fs), + gitdir, + tree + }); + } catch (err) { + err.caller = "git.writeTree"; + throw err; + } +} +var index = { + Errors, + STAGE, + TREE, + WORKDIR, + add, + abortMerge, + addNote, + addRemote, + annotatedTag, + branch, + checkout, + clone, + commit, + getConfig, + getConfigAll, + setConfig, + currentBranch, + deleteBranch, + deleteRef, + deleteRemote, + deleteTag, + expandOid, + expandRef, + fastForward, + fetch, + findMergeBase, + findRoot, + getRemoteInfo, + getRemoteInfo2, + hashBlob, + indexPack, + init, + isDescendent, + isIgnored, + listBranches, + listFiles, + listNotes, + listRemotes, + listServerRefs, + listTags, + log, + merge, + packObjects, + pull, + push, + readBlob, + readCommit, + readNote, + readObject, + readTag, + readTree, + remove, + removeNote, + renameBranch, + resetIndex, + updateIndex, + resolveRef, + status, + statusMatrix, + tag, + version, + walk, + writeBlob, + writeCommit, + writeObject, + writeRef, + writeTag, + writeTree +}; +var isomorphic_git_default = index; + +// src/main.ts +var import_obsidian30 = require("obsidian"); + +// src/lineAuthor/lineAuthorIntegration.ts +init_polyfill_buffer(); +var import_obsidian12 = require("obsidian"); + +// src/gitManager/simpleGit.ts +init_polyfill_buffer(); +var import_child_process2 = require("child_process"); +var import_debug2 = __toESM(require_browser()); +var import_obsidian4 = require("obsidian"); +var path = __toESM(require("path")); +var import_path = require("path"); + +// node_modules/.pnpm/github.com+Vinzent03+git-js@6b9a2d899bc8256e38a1d6f0b8a88116ba2bf56a_supports-color@9.4.0_rdkutdaeyye3o67thmklazfzta/node_modules/simple-git/dist/esm/index.js +init_polyfill_buffer(); +var import_file_exists = __toESM(require_dist(), 1); +var import_debug = __toESM(require_browser(), 1); +var import_child_process = require("child_process"); +var import_promise_deferred = __toESM(require_dist2(), 1); +var import_promise_deferred2 = __toESM(require_dist2(), 1); +var __defProp2 = Object.defineProperty; +var __defProps = Object.defineProperties; +var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor; +var __getOwnPropDescs = Object.getOwnPropertyDescriptors; +var __getOwnPropNames2 = Object.getOwnPropertyNames; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __hasOwnProp2 = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp2 = (obj, key2, value) => key2 in obj ? __defProp2(obj, key2, { enumerable: true, configurable: true, writable: true, value }) : obj[key2] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp2.call(b, prop)) + __defNormalProp2(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp2(a, prop, b[prop]); + } + return a; +}; +var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); +var __markAsModule = (target) => __defProp2(target, "__esModule", { value: true }); +var __esm2 = (fn, res) => function __init() { + return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res; +}; +var __commonJS2 = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export2 = (target, all) => { + for (var name in all) + __defProp2(target, name, { get: all[name], enumerable: true }); +}; +var __reExport = (target, module2, copyDefault, desc) => { + if (module2 && typeof module2 === "object" || typeof module2 === "function") { + for (let key2 of __getOwnPropNames2(module2)) + if (!__hasOwnProp2.call(target, key2) && (copyDefault || key2 !== "default")) + __defProp2(target, key2, { get: () => module2[key2], enumerable: !(desc = __getOwnPropDesc2(module2, key2)) || desc.enumerable }); + } + return target; +}; +var __toCommonJS2 = /* @__PURE__ */ ((cache) => { + return (module2, temp) => { + return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp); + }; +})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0); +var __async = (__this, __arguments, generator) => { + return new Promise((resolve, reject) => { + var fulfilled = (value) => { + try { + step(generator.next(value)); + } catch (e) { + reject(e); + } + }; + var rejected = (value) => { + try { + step(generator.throw(value)); + } catch (e) { + reject(e); + } + }; + var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected); + step((generator = generator.apply(__this, __arguments)).next()); + }); +}; +var GitError; +var init_git_error = __esm2({ + "src/lib/errors/git-error.ts"() { + GitError = class extends Error { + constructor(task, message) { + super(message); + this.task = task; + Object.setPrototypeOf(this, new.target.prototype); + } + }; + } +}); +var GitResponseError; +var init_git_response_error = __esm2({ + "src/lib/errors/git-response-error.ts"() { + init_git_error(); + GitResponseError = class extends GitError { + constructor(git, message) { + super(void 0, message || String(git)); + this.git = git; + } + }; + } +}); +var TaskConfigurationError; +var init_task_configuration_error = __esm2({ + "src/lib/errors/task-configuration-error.ts"() { + init_git_error(); + TaskConfigurationError = class extends GitError { + constructor(message) { + super(void 0, message); + } + }; + } +}); +function asFunction(source) { + return typeof source === "function" ? source : NOOP; +} +function isUserFunction(source) { + return typeof source === "function" && source !== NOOP; +} +function splitOn(input, char) { + const index2 = input.indexOf(char); + if (index2 <= 0) { + return [input, ""]; + } + return [input.substr(0, index2), input.substr(index2 + 1)]; +} +function first(input, offset = 0) { + return isArrayLike(input) && input.length > offset ? input[offset] : void 0; +} +function last(input, offset = 0) { + if (isArrayLike(input) && input.length > offset) { + return input[input.length - 1 - offset]; + } +} +function isArrayLike(input) { + return !!(input && typeof input.length === "number"); +} +function toLinesWithContent(input = "", trimmed2 = true, separator2 = "\n") { + return input.split(separator2).reduce((output, line) => { + const lineContent = trimmed2 ? line.trim() : line; + if (lineContent) { + output.push(lineContent); + } + return output; + }, []); +} +function forEachLineWithContent(input, callback) { + return toLinesWithContent(input, true).map((line) => callback(line)); +} +function folderExists(path2) { + return (0, import_file_exists.exists)(path2, import_file_exists.FOLDER); +} +function append(target, item) { + if (Array.isArray(target)) { + if (!target.includes(item)) { + target.push(item); + } + } else { + target.add(item); + } + return item; +} +function including(target, item) { + if (Array.isArray(target) && !target.includes(item)) { + target.push(item); + } + return target; +} +function remove2(target, item) { + if (Array.isArray(target)) { + const index2 = target.indexOf(item); + if (index2 >= 0) { + target.splice(index2, 1); + } + } else { + target.delete(item); + } + return item; +} +function asArray(source) { + return Array.isArray(source) ? source : [source]; +} +function asStringArray(source) { + return asArray(source).map(String); +} +function asNumber(source, onNaN = 0) { + if (source == null) { + return onNaN; + } + const num2 = parseInt(source, 10); + return isNaN(num2) ? onNaN : num2; +} +function prefixedArray(input, prefix) { + const output = []; + for (let i = 0, max = input.length; i < max; i++) { + output.push(prefix, input[i]); + } + return output; +} +function bufferToString(input) { + return (Array.isArray(input) ? Buffer.concat(input) : input).toString("utf-8"); +} +function pick(source, properties) { + return Object.assign({}, ...properties.map((property) => property in source ? { [property]: source[property] } : {})); +} +function delay(duration = 0) { + return new Promise((done) => setTimeout(done, duration)); +} +var NULL; +var NOOP; +var objectToString; +var init_util = __esm2({ + "src/lib/utils/util.ts"() { + NULL = "\0"; + NOOP = () => { + }; + objectToString = Object.prototype.toString.call.bind(Object.prototype.toString); + } +}); +function filterType(input, filter, def) { + if (filter(input)) { + return input; + } + return arguments.length > 2 ? def : void 0; +} +function filterPrimitives(input, omit) { + return /number|string|boolean/.test(typeof input) && (!omit || !omit.includes(typeof input)); +} +function filterPlainObject(input) { + return !!input && objectToString(input) === "[object Object]"; +} +function filterFunction(input) { + return typeof input === "function"; +} +var filterArray; +var filterString; +var filterStringArray; +var filterStringOrStringArray; +var filterHasLength; +var init_argument_filters = __esm2({ + "src/lib/utils/argument-filters.ts"() { + init_util(); + filterArray = (input) => { + return Array.isArray(input); + }; + filterString = (input) => { + return typeof input === "string"; + }; + filterStringArray = (input) => { + return Array.isArray(input) && input.every(filterString); + }; + filterStringOrStringArray = (input) => { + return filterString(input) || Array.isArray(input) && input.every(filterString); + }; + filterHasLength = (input) => { + if (input == null || "number|boolean|function".includes(typeof input)) { + return false; + } + return Array.isArray(input) || typeof input === "string" || typeof input.length === "number"; + }; + } +}); +var ExitCodes; +var init_exit_codes = __esm2({ + "src/lib/utils/exit-codes.ts"() { + ExitCodes = /* @__PURE__ */ ((ExitCodes2) => { + ExitCodes2[ExitCodes2["SUCCESS"] = 0] = "SUCCESS"; + ExitCodes2[ExitCodes2["ERROR"] = 1] = "ERROR"; + ExitCodes2[ExitCodes2["NOT_FOUND"] = -2] = "NOT_FOUND"; + ExitCodes2[ExitCodes2["UNCLEAN"] = 128] = "UNCLEAN"; + return ExitCodes2; + })(ExitCodes || {}); + } +}); +var GitOutputStreams; +var init_git_output_streams = __esm2({ + "src/lib/utils/git-output-streams.ts"() { + GitOutputStreams = class { + constructor(stdOut, stdErr) { + this.stdOut = stdOut; + this.stdErr = stdErr; + } + asStrings() { + return new GitOutputStreams(this.stdOut.toString("utf8"), this.stdErr.toString("utf8")); + } + }; + } +}); +var LineParser; +var RemoteLineParser; +var init_line_parser = __esm2({ + "src/lib/utils/line-parser.ts"() { + LineParser = class { + constructor(regExp, useMatches) { + this.matches = []; + this.parse = (line, target) => { + this.resetMatches(); + if (!this._regExp.every((reg, index2) => this.addMatch(reg, index2, line(index2)))) { + return false; + } + return this.useMatches(target, this.prepareMatches()) !== false; + }; + this._regExp = Array.isArray(regExp) ? regExp : [regExp]; + if (useMatches) { + this.useMatches = useMatches; + } + } + useMatches(target, match) { + throw new Error(`LineParser:useMatches not implemented`); + } + resetMatches() { + this.matches.length = 0; + } + prepareMatches() { + return this.matches; + } + addMatch(reg, index2, line) { + const matched = line && reg.exec(line); + if (matched) { + this.pushMatch(index2, matched); + } + return !!matched; + } + pushMatch(_index, matched) { + this.matches.push(...matched.slice(1)); + } + }; + RemoteLineParser = class extends LineParser { + addMatch(reg, index2, line) { + return /^remote:\s/.test(String(line)) && super.addMatch(reg, index2, line); + } + pushMatch(index2, matched) { + if (index2 > 0 || matched.length > 1) { + super.pushMatch(index2, matched); + } + } + }; + } +}); +function createInstanceConfig(...options) { + const baseDir = process.cwd(); + const config = Object.assign(__spreadValues({ baseDir }, defaultOptions), ...options.filter((o) => typeof o === "object" && o)); + config.baseDir = config.baseDir || baseDir; + config.trimmed = config.trimmed === true; + return config; +} +var defaultOptions; +var init_simple_git_options = __esm2({ + "src/lib/utils/simple-git-options.ts"() { + defaultOptions = { + binary: "git", + maxConcurrentProcesses: 5, + config: [], + trimmed: false + }; + } +}); +function appendTaskOptions(options, commands2 = []) { + if (!filterPlainObject(options)) { + return commands2; + } + return Object.keys(options).reduce((commands22, key2) => { + const value = options[key2]; + if (filterPrimitives(value, ["boolean"])) { + commands22.push(key2 + "=" + value); + } else { + commands22.push(key2); + } + return commands22; + }, commands2); +} +function getTrailingOptions(args, initialPrimitive = 0, objectOnly = false) { + const command = []; + for (let i = 0, max = initialPrimitive < 0 ? args.length : initialPrimitive; i < max; i++) { + if ("string|number".includes(typeof args[i])) { + command.push(String(args[i])); + } + } + appendTaskOptions(trailingOptionsArgument(args), command); + if (!objectOnly) { + command.push(...trailingArrayArgument(args)); + } + return command; +} +function trailingArrayArgument(args) { + const hasTrailingCallback = typeof last(args) === "function"; + return filterType(last(args, hasTrailingCallback ? 1 : 0), filterArray, []); +} +function trailingOptionsArgument(args) { + const hasTrailingCallback = filterFunction(last(args)); + return filterType(last(args, hasTrailingCallback ? 1 : 0), filterPlainObject); +} +function trailingFunctionArgument(args, includeNoop = true) { + const callback = asFunction(last(args)); + return includeNoop || isUserFunction(callback) ? callback : void 0; +} +var init_task_options = __esm2({ + "src/lib/utils/task-options.ts"() { + init_argument_filters(); + init_util(); + } +}); +function callTaskParser(parser3, streams) { + return parser3(streams.stdOut, streams.stdErr); +} +function parseStringResponse(result, parsers12, texts, trim = true) { + asArray(texts).forEach((text2) => { + for (let lines = toLinesWithContent(text2, trim), i = 0, max = lines.length; i < max; i++) { + const line = (offset = 0) => { + if (i + offset >= max) { + return; + } + return lines[i + offset]; + }; + parsers12.some(({ parse: parse2 }) => parse2(line, result)); + } + }); + return result; +} +var init_task_parser = __esm2({ + "src/lib/utils/task-parser.ts"() { + init_util(); + } +}); +var utils_exports = {}; +__export2(utils_exports, { + ExitCodes: () => ExitCodes, + GitOutputStreams: () => GitOutputStreams, + LineParser: () => LineParser, + NOOP: () => NOOP, + NULL: () => NULL, + RemoteLineParser: () => RemoteLineParser, + append: () => append, + appendTaskOptions: () => appendTaskOptions, + asArray: () => asArray, + asFunction: () => asFunction, + asNumber: () => asNumber, + asStringArray: () => asStringArray, + bufferToString: () => bufferToString, + callTaskParser: () => callTaskParser, + createInstanceConfig: () => createInstanceConfig, + delay: () => delay, + filterArray: () => filterArray, + filterFunction: () => filterFunction, + filterHasLength: () => filterHasLength, + filterPlainObject: () => filterPlainObject, + filterPrimitives: () => filterPrimitives, + filterString: () => filterString, + filterStringArray: () => filterStringArray, + filterStringOrStringArray: () => filterStringOrStringArray, + filterType: () => filterType, + first: () => first, + folderExists: () => folderExists, + forEachLineWithContent: () => forEachLineWithContent, + getTrailingOptions: () => getTrailingOptions, + including: () => including, + isUserFunction: () => isUserFunction, + last: () => last, + objectToString: () => objectToString, + parseStringResponse: () => parseStringResponse, + pick: () => pick, + prefixedArray: () => prefixedArray, + remove: () => remove2, + splitOn: () => splitOn, + toLinesWithContent: () => toLinesWithContent, + trailingFunctionArgument: () => trailingFunctionArgument, + trailingOptionsArgument: () => trailingOptionsArgument +}); +var init_utils = __esm2({ + "src/lib/utils/index.ts"() { + init_argument_filters(); + init_exit_codes(); + init_git_output_streams(); + init_line_parser(); + init_simple_git_options(); + init_task_options(); + init_task_parser(); + init_util(); + } +}); +var check_is_repo_exports = {}; +__export2(check_is_repo_exports, { + CheckRepoActions: () => CheckRepoActions, + checkIsBareRepoTask: () => checkIsBareRepoTask, + checkIsRepoRootTask: () => checkIsRepoRootTask, + checkIsRepoTask: () => checkIsRepoTask +}); +function checkIsRepoTask(action) { + switch (action) { + case "bare": + return checkIsBareRepoTask(); + case "root": + return checkIsRepoRootTask(); + } + const commands2 = ["rev-parse", "--is-inside-work-tree"]; + return { + commands: commands2, + format: "utf-8", + onError, + parser + }; +} +function checkIsRepoRootTask() { + const commands2 = ["rev-parse", "--git-dir"]; + return { + commands: commands2, + format: "utf-8", + onError, + parser(path2) { + return /^\.(git)?$/.test(path2.trim()); + } + }; +} +function checkIsBareRepoTask() { + const commands2 = ["rev-parse", "--is-bare-repository"]; + return { + commands: commands2, + format: "utf-8", + onError, + parser + }; +} +function isNotRepoMessage(error) { + return /(Not a git repository|Kein Git-Repository)/i.test(String(error)); +} +var CheckRepoActions; +var onError; +var parser; +var init_check_is_repo = __esm2({ + "src/lib/tasks/check-is-repo.ts"() { + init_utils(); + CheckRepoActions = /* @__PURE__ */ ((CheckRepoActions2) => { + CheckRepoActions2["BARE"] = "bare"; + CheckRepoActions2["IN_TREE"] = "tree"; + CheckRepoActions2["IS_REPO_ROOT"] = "root"; + return CheckRepoActions2; + })(CheckRepoActions || {}); + onError = ({ exitCode }, error, done, fail) => { + if (exitCode === 128 && isNotRepoMessage(error)) { + return done(Buffer.from("false")); + } + fail(error); + }; + parser = (text2) => { + return text2.trim() === "true"; + }; + } +}); +function cleanSummaryParser(dryRun, text2) { + const summary = new CleanResponse(dryRun); + const regexp = dryRun ? dryRunRemovalRegexp : removalRegexp; + toLinesWithContent(text2).forEach((line) => { + const removed = line.replace(regexp, ""); + summary.paths.push(removed); + (isFolderRegexp.test(removed) ? summary.folders : summary.files).push(removed); + }); + return summary; +} +var CleanResponse; +var removalRegexp; +var dryRunRemovalRegexp; +var isFolderRegexp; +var init_CleanSummary = __esm2({ + "src/lib/responses/CleanSummary.ts"() { + init_utils(); + CleanResponse = class { + constructor(dryRun) { + this.dryRun = dryRun; + this.paths = []; + this.files = []; + this.folders = []; + } + }; + removalRegexp = /^[a-z]+\s*/i; + dryRunRemovalRegexp = /^[a-z]+\s+[a-z]+\s*/i; + isFolderRegexp = /\/$/; + } +}); +var task_exports = {}; +__export2(task_exports, { + EMPTY_COMMANDS: () => EMPTY_COMMANDS, + adhocExecTask: () => adhocExecTask, + configurationErrorTask: () => configurationErrorTask, + isBufferTask: () => isBufferTask, + isEmptyTask: () => isEmptyTask, + straightThroughBufferTask: () => straightThroughBufferTask, + straightThroughStringTask: () => straightThroughStringTask +}); +function adhocExecTask(parser3) { + return { + commands: EMPTY_COMMANDS, + format: "empty", + parser: parser3 + }; +} +function configurationErrorTask(error) { + return { + commands: EMPTY_COMMANDS, + format: "empty", + parser() { + throw typeof error === "string" ? new TaskConfigurationError(error) : error; + } + }; +} +function straightThroughStringTask(commands2, trimmed2 = false) { + return { + commands: commands2, + format: "utf-8", + parser(text2) { + return trimmed2 ? String(text2).trim() : text2; + } + }; +} +function straightThroughBufferTask(commands2) { + return { + commands: commands2, + format: "buffer", + parser(buffer2) { + return buffer2; + } + }; +} +function isBufferTask(task) { + return task.format === "buffer"; +} +function isEmptyTask(task) { + return task.format === "empty" || !task.commands.length; +} +var EMPTY_COMMANDS; +var init_task = __esm2({ + "src/lib/tasks/task.ts"() { + init_task_configuration_error(); + EMPTY_COMMANDS = []; + } +}); +var clean_exports = {}; +__export2(clean_exports, { + CONFIG_ERROR_INTERACTIVE_MODE: () => CONFIG_ERROR_INTERACTIVE_MODE, + CONFIG_ERROR_MODE_REQUIRED: () => CONFIG_ERROR_MODE_REQUIRED, + CONFIG_ERROR_UNKNOWN_OPTION: () => CONFIG_ERROR_UNKNOWN_OPTION, + CleanOptions: () => CleanOptions, + cleanTask: () => cleanTask, + cleanWithOptionsTask: () => cleanWithOptionsTask, + isCleanOptionsArray: () => isCleanOptionsArray +}); +function cleanWithOptionsTask(mode, customArgs) { + const { cleanMode, options, valid } = getCleanOptions(mode); + if (!cleanMode) { + return configurationErrorTask(CONFIG_ERROR_MODE_REQUIRED); + } + if (!valid.options) { + return configurationErrorTask(CONFIG_ERROR_UNKNOWN_OPTION + JSON.stringify(mode)); + } + options.push(...customArgs); + if (options.some(isInteractiveMode)) { + return configurationErrorTask(CONFIG_ERROR_INTERACTIVE_MODE); + } + return cleanTask(cleanMode, options); +} +function cleanTask(mode, customArgs) { + const commands2 = ["clean", `-${mode}`, ...customArgs]; + return { + commands: commands2, + format: "utf-8", + parser(text2) { + return cleanSummaryParser(mode === "n", text2); + } + }; +} +function isCleanOptionsArray(input) { + return Array.isArray(input) && input.every((test) => CleanOptionValues.has(test)); +} +function getCleanOptions(input) { + let cleanMode; + let options = []; + let valid = { cleanMode: false, options: true }; + input.replace(/[^a-z]i/g, "").split("").forEach((char) => { + if (isCleanMode(char)) { + cleanMode = char; + valid.cleanMode = true; + } else { + valid.options = valid.options && isKnownOption(options[options.length] = `-${char}`); + } + }); + return { + cleanMode, + options, + valid + }; +} +function isCleanMode(cleanMode) { + return cleanMode === "f" || cleanMode === "n"; +} +function isKnownOption(option) { + return /^-[a-z]$/i.test(option) && CleanOptionValues.has(option.charAt(1)); +} +function isInteractiveMode(option) { + if (/^-[^\-]/.test(option)) { + return option.indexOf("i") > 0; + } + return option === "--interactive"; +} +var CONFIG_ERROR_INTERACTIVE_MODE; +var CONFIG_ERROR_MODE_REQUIRED; +var CONFIG_ERROR_UNKNOWN_OPTION; +var CleanOptions; +var CleanOptionValues; +var init_clean = __esm2({ + "src/lib/tasks/clean.ts"() { + init_CleanSummary(); + init_utils(); + init_task(); + CONFIG_ERROR_INTERACTIVE_MODE = "Git clean interactive mode is not supported"; + CONFIG_ERROR_MODE_REQUIRED = 'Git clean mode parameter ("n" or "f") is required'; + CONFIG_ERROR_UNKNOWN_OPTION = "Git clean unknown option found in: "; + CleanOptions = /* @__PURE__ */ ((CleanOptions2) => { + CleanOptions2["DRY_RUN"] = "n"; + CleanOptions2["FORCE"] = "f"; + CleanOptions2["IGNORED_INCLUDED"] = "x"; + CleanOptions2["IGNORED_ONLY"] = "X"; + CleanOptions2["EXCLUDING"] = "e"; + CleanOptions2["QUIET"] = "q"; + CleanOptions2["RECURSIVE"] = "d"; + return CleanOptions2; + })(CleanOptions || {}); + CleanOptionValues = /* @__PURE__ */ new Set([ + "i", + ...asStringArray(Object.values(CleanOptions)) + ]); + } +}); +function configListParser(text2) { + const config = new ConfigList(); + for (const item of configParser(text2)) { + config.addValue(item.file, String(item.key), item.value); + } + return config; +} +function configGetParser(text2, key2) { + let value = null; + const values = []; + const scopes = /* @__PURE__ */ new Map(); + for (const item of configParser(text2, key2)) { + if (item.key !== key2) { + continue; + } + values.push(value = item.value); + if (!scopes.has(item.file)) { + scopes.set(item.file, []); + } + scopes.get(item.file).push(value); + } + return { + key: key2, + paths: Array.from(scopes.keys()), + scopes, + value, + values + }; +} +function configFilePath(filePath) { + return filePath.replace(/^(file):/, ""); +} +function* configParser(text2, requestedKey = null) { + const lines = text2.split("\0"); + for (let i = 0, max = lines.length - 1; i < max; ) { + const file = configFilePath(lines[i++]); + let value = lines[i++]; + let key2 = requestedKey; + if (value.includes("\n")) { + const line = splitOn(value, "\n"); + key2 = line[0]; + value = line[1]; + } + yield { file, key: key2, value }; + } +} +var ConfigList; +var init_ConfigList = __esm2({ + "src/lib/responses/ConfigList.ts"() { + init_utils(); + ConfigList = class { + constructor() { + this.files = []; + this.values = /* @__PURE__ */ Object.create(null); + } + get all() { + if (!this._all) { + this._all = this.files.reduce((all, file) => { + return Object.assign(all, this.values[file]); + }, {}); + } + return this._all; + } + addFile(file) { + if (!(file in this.values)) { + const latest = last(this.files); + this.values[file] = latest ? Object.create(this.values[latest]) : {}; + this.files.push(file); + } + return this.values[file]; + } + addValue(file, key2, value) { + const values = this.addFile(file); + if (!values.hasOwnProperty(key2)) { + values[key2] = value; + } else if (Array.isArray(values[key2])) { + values[key2].push(value); + } else { + values[key2] = [values[key2], value]; + } + this._all = void 0; + } + }; + } +}); +function asConfigScope(scope, fallback) { + if (typeof scope === "string" && GitConfigScope.hasOwnProperty(scope)) { + return scope; + } + return fallback; +} +function addConfigTask(key2, value, append22, scope) { + const commands2 = ["config", `--${scope}`]; + if (append22) { + commands2.push("--add"); + } + commands2.push(key2, value); + return { + commands: commands2, + format: "utf-8", + parser(text2) { + return text2; + } + }; +} +function getConfigTask(key2, scope) { + const commands2 = ["config", "--null", "--show-origin", "--get-all", key2]; + if (scope) { + commands2.splice(1, 0, `--${scope}`); + } + return { + commands: commands2, + format: "utf-8", + parser(text2) { + return configGetParser(text2, key2); + } + }; +} +function listConfigTask(scope) { + const commands2 = ["config", "--list", "--show-origin", "--null"]; + if (scope) { + commands2.push(`--${scope}`); + } + return { + commands: commands2, + format: "utf-8", + parser(text2) { + return configListParser(text2); + } + }; +} +function config_default() { + return { + addConfig(key2, value, ...rest) { + return this._runTask(addConfigTask(key2, value, rest[0] === true, asConfigScope( + rest[1], + "local" + /* local */ + )), trailingFunctionArgument(arguments)); + }, + getConfig(key2, scope) { + return this._runTask(getConfigTask(key2, asConfigScope(scope, void 0)), trailingFunctionArgument(arguments)); + }, + listConfig(...rest) { + return this._runTask(listConfigTask(asConfigScope(rest[0], void 0)), trailingFunctionArgument(arguments)); + } + }; +} +var GitConfigScope; +var init_config = __esm2({ + "src/lib/tasks/config.ts"() { + init_ConfigList(); + init_utils(); + GitConfigScope = /* @__PURE__ */ ((GitConfigScope2) => { + GitConfigScope2["system"] = "system"; + GitConfigScope2["global"] = "global"; + GitConfigScope2["local"] = "local"; + GitConfigScope2["worktree"] = "worktree"; + return GitConfigScope2; + })(GitConfigScope || {}); + } +}); +function grepQueryBuilder(...params) { + return new GrepQuery().param(...params); +} +function parseGrep(grep) { + const paths = /* @__PURE__ */ new Set(); + const results = {}; + forEachLineWithContent(grep, (input) => { + const [path2, line, preview] = input.split(NULL); + paths.add(path2); + (results[path2] = results[path2] || []).push({ + line: asNumber(line), + path: path2, + preview + }); + }); + return { + paths, + results + }; +} +function grep_default() { + return { + grep(searchTerm) { + const then = trailingFunctionArgument(arguments); + const options = getTrailingOptions(arguments); + for (const option of disallowedOptions) { + if (options.includes(option)) { + return this._runTask(configurationErrorTask(`git.grep: use of "${option}" is not supported.`), then); + } + } + if (typeof searchTerm === "string") { + searchTerm = grepQueryBuilder().param(searchTerm); + } + const commands2 = ["grep", "--null", "-n", "--full-name", ...options, ...searchTerm]; + return this._runTask({ + commands: commands2, + format: "utf-8", + parser(stdOut) { + return parseGrep(stdOut); + } + }, then); + } + }; +} +var disallowedOptions; +var Query; +var _a; +var GrepQuery; +var init_grep = __esm2({ + "src/lib/tasks/grep.ts"() { + init_utils(); + init_task(); + disallowedOptions = ["-h"]; + Query = Symbol("grepQuery"); + GrepQuery = class { + constructor() { + this[_a] = []; + } + *[(_a = Query, Symbol.iterator)]() { + for (const query of this[Query]) { + yield query; + } + } + and(...and) { + and.length && this[Query].push("--and", "(", ...prefixedArray(and, "-e"), ")"); + return this; + } + param(...param) { + this[Query].push(...prefixedArray(param, "-e")); + return this; + } + }; + } +}); +var reset_exports = {}; +__export2(reset_exports, { + ResetMode: () => ResetMode, + getResetMode: () => getResetMode, + resetTask: () => resetTask +}); +function resetTask(mode, customArgs) { + const commands2 = ["reset"]; + if (isValidResetMode(mode)) { + commands2.push(`--${mode}`); + } + commands2.push(...customArgs); + return straightThroughStringTask(commands2); +} +function getResetMode(mode) { + if (isValidResetMode(mode)) { + return mode; + } + switch (typeof mode) { + case "string": + case "undefined": + return "soft"; + } + return; +} +function isValidResetMode(mode) { + return ResetModes.includes(mode); +} +var ResetMode; +var ResetModes; +var init_reset = __esm2({ + "src/lib/tasks/reset.ts"() { + init_task(); + ResetMode = /* @__PURE__ */ ((ResetMode2) => { + ResetMode2["MIXED"] = "mixed"; + ResetMode2["SOFT"] = "soft"; + ResetMode2["HARD"] = "hard"; + ResetMode2["MERGE"] = "merge"; + ResetMode2["KEEP"] = "keep"; + return ResetMode2; + })(ResetMode || {}); + ResetModes = Array.from(Object.values(ResetMode)); + } +}); +function createLog() { + return (0, import_debug.default)("simple-git"); +} +function prefixedLogger(to, prefix, forward) { + if (!prefix || !String(prefix).replace(/\s*/, "")) { + return !forward ? to : (message, ...args) => { + to(message, ...args); + forward(message, ...args); + }; + } + return (message, ...args) => { + to(`%s ${message}`, prefix, ...args); + if (forward) { + forward(message, ...args); + } + }; +} +function childLoggerName(name, childDebugger, { namespace: parentNamespace }) { + if (typeof name === "string") { + return name; + } + const childNamespace = childDebugger && childDebugger.namespace || ""; + if (childNamespace.startsWith(parentNamespace)) { + return childNamespace.substr(parentNamespace.length + 1); + } + return childNamespace || parentNamespace; +} +function createLogger(label, verbose, initialStep, infoDebugger = createLog()) { + const labelPrefix = label && `[${label}]` || ""; + const spawned = []; + const debugDebugger = typeof verbose === "string" ? infoDebugger.extend(verbose) : verbose; + const key2 = childLoggerName(filterType(verbose, filterString), debugDebugger, infoDebugger); + return step(initialStep); + function sibling(name, initial) { + return append(spawned, createLogger(label, key2.replace(/^[^:]+/, name), initial, infoDebugger)); + } + function step(phase) { + const stepPrefix = phase && `[${phase}]` || ""; + const debug22 = debugDebugger && prefixedLogger(debugDebugger, stepPrefix) || NOOP; + const info = prefixedLogger(infoDebugger, `${labelPrefix} ${stepPrefix}`, debug22); + return Object.assign(debugDebugger ? debug22 : info, { + label, + sibling, + info, + step + }); + } +} +var init_git_logger = __esm2({ + "src/lib/git-logger.ts"() { + init_utils(); + import_debug.default.formatters.L = (value) => String(filterHasLength(value) ? value.length : "-"); + import_debug.default.formatters.B = (value) => { + if (Buffer.isBuffer(value)) { + return value.toString("utf8"); + } + return objectToString(value); + }; + } +}); +var _TasksPendingQueue; +var TasksPendingQueue; +var init_tasks_pending_queue = __esm2({ + "src/lib/runners/tasks-pending-queue.ts"() { + init_git_error(); + init_git_logger(); + _TasksPendingQueue = class { + constructor(logLabel = "GitExecutor") { + this.logLabel = logLabel; + this._queue = /* @__PURE__ */ new Map(); + } + withProgress(task) { + return this._queue.get(task); + } + createProgress(task) { + const name = _TasksPendingQueue.getName(task.commands[0]); + const logger = createLogger(this.logLabel, name); + return { + task, + logger, + name + }; + } + push(task) { + const progress = this.createProgress(task); + progress.logger("Adding task to the queue, commands = %o", task.commands); + this._queue.set(task, progress); + return progress; + } + fatal(err) { + for (const [task, { logger }] of Array.from(this._queue.entries())) { + if (task === err.task) { + logger.info(`Failed %o`, err); + logger(`Fatal exception, any as-yet un-started tasks run through this executor will not be attempted`); + } else { + logger.info(`A fatal exception occurred in a previous task, the queue has been purged: %o`, err.message); + } + this.complete(task); + } + if (this._queue.size !== 0) { + throw new Error(`Queue size should be zero after fatal: ${this._queue.size}`); + } + } + complete(task) { + const progress = this.withProgress(task); + if (progress) { + this._queue.delete(task); + } + } + attempt(task) { + const progress = this.withProgress(task); + if (!progress) { + throw new GitError(void 0, "TasksPendingQueue: attempt called for an unknown task"); + } + progress.logger("Starting task"); + return progress; + } + static getName(name = "empty") { + return `task:${name}:${++_TasksPendingQueue.counter}`; + } + }; + TasksPendingQueue = _TasksPendingQueue; + TasksPendingQueue.counter = 0; + } +}); +function pluginContext(task, commands2) { + return { + method: first(task.commands) || "", + commands: commands2 + }; +} +function onErrorReceived(target, logger) { + return (err) => { + logger(`[ERROR] child process exception %o`, err); + target.push(Buffer.from(String(err.stack), "ascii")); + }; +} +function onDataReceived(target, name, logger, output) { + return (buffer2) => { + logger(`%s received %L bytes`, name, buffer2); + output(`%B`, buffer2); + target.push(buffer2); + }; +} +var GitExecutorChain; +var init_git_executor_chain = __esm2({ + "src/lib/runners/git-executor-chain.ts"() { + init_git_error(); + init_task(); + init_utils(); + init_tasks_pending_queue(); + GitExecutorChain = class { + constructor(_executor, _scheduler, _plugins) { + this._executor = _executor; + this._scheduler = _scheduler; + this._plugins = _plugins; + this._chain = Promise.resolve(); + this._queue = new TasksPendingQueue(); + } + get binary() { + return this._executor.binary; + } + get cwd() { + return this._cwd || this._executor.cwd; + } + set cwd(cwd) { + this._cwd = cwd; + } + get env() { + return this._executor.env; + } + get outputHandler() { + return this._executor.outputHandler; + } + chain() { + return this; + } + push(task) { + this._queue.push(task); + return this._chain = this._chain.then(() => this.attemptTask(task)); + } + attemptTask(task) { + return __async(this, null, function* () { + const onScheduleComplete = yield this._scheduler.next(); + const onQueueComplete = () => this._queue.complete(task); + try { + const { logger } = this._queue.attempt(task); + return yield isEmptyTask(task) ? this.attemptEmptyTask(task, logger) : this.attemptRemoteTask(task, logger); + } catch (e) { + throw this.onFatalException(task, e); + } finally { + onQueueComplete(); + onScheduleComplete(); + } + }); + } + onFatalException(task, e) { + const gitError = e instanceof GitError ? Object.assign(e, { task }) : new GitError(task, e && String(e)); + this._chain = Promise.resolve(); + this._queue.fatal(gitError); + return gitError; + } + attemptRemoteTask(task, logger) { + return __async(this, null, function* () { + const args = this._plugins.exec("spawn.args", [...task.commands], pluginContext(task, task.commands)); + const raw = yield this.gitResponse(task, this.binary, args, this.outputHandler, logger.step("SPAWN")); + const outputStreams = yield this.handleTaskData(task, args, raw, logger.step("HANDLE")); + logger(`passing response to task's parser as a %s`, task.format); + if (isBufferTask(task)) { + return callTaskParser(task.parser, outputStreams); + } + return callTaskParser(task.parser, outputStreams.asStrings()); + }); + } + attemptEmptyTask(task, logger) { + return __async(this, null, function* () { + logger(`empty task bypassing child process to call to task's parser`); + return task.parser(this); + }); + } + handleTaskData(task, args, result, logger) { + const { exitCode, rejection, stdOut, stdErr } = result; + return new Promise((done, fail) => { + logger(`Preparing to handle process response exitCode=%d stdOut=`, exitCode); + const { error } = this._plugins.exec("task.error", { error: rejection }, __spreadValues(__spreadValues({}, pluginContext(task, args)), result)); + if (error && task.onError) { + logger.info(`exitCode=%s handling with custom error handler`); + return task.onError(result, error, (newStdOut) => { + logger.info(`custom error handler treated as success`); + logger(`custom error returned a %s`, objectToString(newStdOut)); + done(new GitOutputStreams(Array.isArray(newStdOut) ? Buffer.concat(newStdOut) : newStdOut, Buffer.concat(stdErr))); + }, fail); + } + if (error) { + logger.info(`handling as error: exitCode=%s stdErr=%s rejection=%o`, exitCode, stdErr.length, rejection); + return fail(error); + } + logger.info(`retrieving task output complete`); + done(new GitOutputStreams(Buffer.concat(stdOut), Buffer.concat(stdErr))); + }); + } + gitResponse(task, command, args, outputHandler, logger) { + return __async(this, null, function* () { + const outputLogger = logger.sibling("output"); + const spawnOptions = this._plugins.exec("spawn.options", { + cwd: this.cwd, + env: this.env, + windowsHide: true + }, pluginContext(task, task.commands)); + return new Promise((done) => { + const stdOut = []; + const stdErr = []; + logger.info(`%s %o`, command, args); + logger("%O", spawnOptions); + let rejection = this._beforeSpawn(task, args); + if (rejection) { + return done({ + stdOut, + stdErr, + exitCode: 9901, + rejection + }); + } + this._plugins.exec("spawn.before", void 0, __spreadProps(__spreadValues({}, pluginContext(task, args)), { + kill(reason) { + rejection = reason || rejection; + } + })); + const spawned = (0, import_child_process.spawn)(command, args, spawnOptions); + spawned.stdout.on("data", onDataReceived(stdOut, "stdOut", logger, outputLogger.step("stdOut"))); + spawned.stderr.on("data", onDataReceived(stdErr, "stdErr", logger, outputLogger.step("stdErr"))); + spawned.on("error", onErrorReceived(stdErr, logger)); + if (outputHandler) { + logger(`Passing child process stdOut/stdErr to custom outputHandler`); + outputHandler(command, spawned.stdout, spawned.stderr, [...args]); + } + this._plugins.exec("spawn.after", void 0, __spreadProps(__spreadValues({}, pluginContext(task, args)), { + spawned, + close(exitCode, reason) { + done({ + stdOut, + stdErr, + exitCode, + rejection: rejection || reason + }); + }, + kill(reason) { + if (spawned.killed) { + return; + } + rejection = reason; + spawned.kill("SIGINT"); + } + })); + }); + }); + } + _beforeSpawn(task, args) { + let rejection; + this._plugins.exec("spawn.before", void 0, __spreadProps(__spreadValues({}, pluginContext(task, args)), { + kill(reason) { + rejection = reason || rejection; + } + })); + return rejection; + } + }; + } +}); +var git_executor_exports = {}; +__export2(git_executor_exports, { + GitExecutor: () => GitExecutor +}); +var GitExecutor; +var init_git_executor = __esm2({ + "src/lib/runners/git-executor.ts"() { + init_git_executor_chain(); + GitExecutor = class { + constructor(binary = "git", cwd, _scheduler, _plugins) { + this.binary = binary; + this.cwd = cwd; + this._scheduler = _scheduler; + this._plugins = _plugins; + this._chain = new GitExecutorChain(this, this._scheduler, this._plugins); + } + chain() { + return new GitExecutorChain(this, this._scheduler, this._plugins); + } + push(task) { + return this._chain.push(task); + } + }; + } +}); +function taskCallback(task, response, callback = NOOP) { + const onSuccess = (data) => { + callback(null, data); + }; + const onError2 = (err) => { + if ((err == null ? void 0 : err.task) === task) { + callback(err instanceof GitResponseError ? addDeprecationNoticeToError(err) : err, void 0); + } + }; + response.then(onSuccess, onError2); +} +function addDeprecationNoticeToError(err) { + let log2 = (name) => { + console.warn(`simple-git deprecation notice: accessing GitResponseError.${name} should be GitResponseError.git.${name}, this will no longer be available in version 3`); + log2 = NOOP; + }; + return Object.create(err, Object.getOwnPropertyNames(err.git).reduce(descriptorReducer, {})); + function descriptorReducer(all, name) { + if (name in err) { + return all; + } + all[name] = { + enumerable: false, + configurable: false, + get() { + log2(name); + return err.git[name]; + } + }; + return all; + } +} +var init_task_callback = __esm2({ + "src/lib/task-callback.ts"() { + init_git_response_error(); + init_utils(); + } +}); +function changeWorkingDirectoryTask(directory, root2) { + return adhocExecTask((instance10) => { + if (!folderExists(directory)) { + throw new Error(`Git.cwd: cannot change to non-directory "${directory}"`); + } + return (root2 || instance10).cwd = directory; + }); +} +var init_change_working_directory = __esm2({ + "src/lib/tasks/change-working-directory.ts"() { + init_utils(); + init_task(); + } +}); +function checkoutTask(args) { + const commands2 = ["checkout", ...args]; + if (commands2[1] === "-b" && commands2.includes("-B")) { + commands2[1] = remove2(commands2, "-B"); + } + return straightThroughStringTask(commands2); +} +function checkout_default() { + return { + checkout() { + return this._runTask(checkoutTask(getTrailingOptions(arguments, 1)), trailingFunctionArgument(arguments)); + }, + checkoutBranch(branchName, startPoint) { + return this._runTask(checkoutTask(["-b", branchName, startPoint, ...getTrailingOptions(arguments)]), trailingFunctionArgument(arguments)); + }, + checkoutLocalBranch(branchName) { + return this._runTask(checkoutTask(["-b", branchName, ...getTrailingOptions(arguments)]), trailingFunctionArgument(arguments)); + } + }; +} +var init_checkout = __esm2({ + "src/lib/tasks/checkout.ts"() { + init_utils(); + init_task(); + } +}); +function parseCommitResult(stdOut) { + const result = { + author: null, + branch: "", + commit: "", + root: false, + summary: { + changes: 0, + insertions: 0, + deletions: 0 + } + }; + return parseStringResponse(result, parsers, stdOut); +} +var parsers; +var init_parse_commit = __esm2({ + "src/lib/parsers/parse-commit.ts"() { + init_utils(); + parsers = [ + new LineParser(/^\[([^\s]+)( \([^)]+\))? ([^\]]+)/, (result, [branch2, root2, commit2]) => { + result.branch = branch2; + result.commit = commit2; + result.root = !!root2; + }), + new LineParser(/\s*Author:\s(.+)/i, (result, [author]) => { + const parts = author.split("<"); + const email = parts.pop(); + if (!email || !email.includes("@")) { + return; + } + result.author = { + email: email.substr(0, email.length - 1), + name: parts.join("<").trim() + }; + }), + new LineParser(/(\d+)[^,]*(?:,\s*(\d+)[^,]*)(?:,\s*(\d+))/g, (result, [changes, insertions, deletions]) => { + result.summary.changes = parseInt(changes, 10) || 0; + result.summary.insertions = parseInt(insertions, 10) || 0; + result.summary.deletions = parseInt(deletions, 10) || 0; + }), + new LineParser(/^(\d+)[^,]*(?:,\s*(\d+)[^(]+\(([+-]))?/, (result, [changes, lines, direction]) => { + result.summary.changes = parseInt(changes, 10) || 0; + const count = parseInt(lines, 10) || 0; + if (direction === "-") { + result.summary.deletions = count; + } else if (direction === "+") { + result.summary.insertions = count; + } + }) + ]; + } +}); +function commitTask(message, files, customArgs) { + const commands2 = [ + "-c", + "core.abbrev=40", + "commit", + ...prefixedArray(message, "-m"), + ...files, + ...customArgs + ]; + return { + commands: commands2, + format: "utf-8", + parser: parseCommitResult + }; +} +function commit_default() { + return { + commit(message, ...rest) { + const next = trailingFunctionArgument(arguments); + const task = rejectDeprecatedSignatures(message) || commitTask(asArray(message), asArray(filterType(rest[0], filterStringOrStringArray, [])), [...filterType(rest[1], filterArray, []), ...getTrailingOptions(arguments, 0, true)]); + return this._runTask(task, next); + } + }; + function rejectDeprecatedSignatures(message) { + return !filterStringOrStringArray(message) && configurationErrorTask(`git.commit: requires the commit message to be supplied as a string/string[]`); + } +} +var init_commit = __esm2({ + "src/lib/tasks/commit.ts"() { + init_parse_commit(); + init_utils(); + init_task(); + } +}); +function hashObjectTask(filePath, write) { + const commands2 = ["hash-object", filePath]; + if (write) { + commands2.push("-w"); + } + return straightThroughStringTask(commands2, true); +} +var init_hash_object = __esm2({ + "src/lib/tasks/hash-object.ts"() { + init_task(); + } +}); +function parseInit(bare, path2, text2) { + const response = String(text2).trim(); + let result; + if (result = initResponseRegex.exec(response)) { + return new InitSummary(bare, path2, false, result[1]); + } + if (result = reInitResponseRegex.exec(response)) { + return new InitSummary(bare, path2, true, result[1]); + } + let gitDir = ""; + const tokens = response.split(" "); + while (tokens.length) { + const token = tokens.shift(); + if (token === "in") { + gitDir = tokens.join(" "); + break; + } + } + return new InitSummary(bare, path2, /^re/i.test(response), gitDir); +} +var InitSummary; +var initResponseRegex; +var reInitResponseRegex; +var init_InitSummary = __esm2({ + "src/lib/responses/InitSummary.ts"() { + InitSummary = class { + constructor(bare, path2, existing, gitDir) { + this.bare = bare; + this.path = path2; + this.existing = existing; + this.gitDir = gitDir; + } + }; + initResponseRegex = /^Init.+ repository in (.+)$/; + reInitResponseRegex = /^Rein.+ in (.+)$/; + } +}); +function hasBareCommand(command) { + return command.includes(bareCommand); +} +function initTask(bare = false, path2, customArgs) { + const commands2 = ["init", ...customArgs]; + if (bare && !hasBareCommand(commands2)) { + commands2.splice(1, 0, bareCommand); + } + return { + commands: commands2, + format: "utf-8", + parser(text2) { + return parseInit(commands2.includes("--bare"), path2, text2); + } + }; +} +var bareCommand; +var init_init = __esm2({ + "src/lib/tasks/init.ts"() { + init_InitSummary(); + bareCommand = "--bare"; + } +}); +function logFormatFromCommand(customArgs) { + for (let i = 0; i < customArgs.length; i++) { + const format = logFormatRegex.exec(customArgs[i]); + if (format) { + return `--${format[1]}`; + } + } + return ""; +} +function isLogFormat(customArg) { + return logFormatRegex.test(customArg); +} +var logFormatRegex; +var init_log_format = __esm2({ + "src/lib/args/log-format.ts"() { + logFormatRegex = /^--(stat|numstat|name-only|name-status)(=|$)/; + } +}); +var DiffSummary; +var init_DiffSummary = __esm2({ + "src/lib/responses/DiffSummary.ts"() { + DiffSummary = class { + constructor() { + this.changed = 0; + this.deletions = 0; + this.insertions = 0; + this.files = []; + } + }; + } +}); +function getDiffParser(format = "") { + const parser3 = diffSummaryParsers[format]; + return (stdOut) => parseStringResponse(new DiffSummary(), parser3, stdOut, false); +} +var statParser; +var numStatParser; +var nameOnlyParser; +var nameStatusParser; +var diffSummaryParsers; +var init_parse_diff_summary = __esm2({ + "src/lib/parsers/parse-diff-summary.ts"() { + init_log_format(); + init_DiffSummary(); + init_utils(); + statParser = [ + new LineParser(/(.+)\s+\|\s+(\d+)(\s+[+\-]+)?$/, (result, [file, changes, alterations = ""]) => { + result.files.push({ + file: file.trim(), + changes: asNumber(changes), + insertions: alterations.replace(/[^+]/g, "").length, + deletions: alterations.replace(/[^-]/g, "").length, + binary: false + }); + }), + new LineParser(/(.+) \|\s+Bin ([0-9.]+) -> ([0-9.]+) ([a-z]+)/, (result, [file, before, after]) => { + result.files.push({ + file: file.trim(), + before: asNumber(before), + after: asNumber(after), + binary: true + }); + }), + new LineParser(/(\d+) files? changed\s*((?:, \d+ [^,]+){0,2})/, (result, [changed, summary]) => { + const inserted = /(\d+) i/.exec(summary); + const deleted = /(\d+) d/.exec(summary); + result.changed = asNumber(changed); + result.insertions = asNumber(inserted == null ? void 0 : inserted[1]); + result.deletions = asNumber(deleted == null ? void 0 : deleted[1]); + }) + ]; + numStatParser = [ + new LineParser(/(\d+)\t(\d+)\t(.+)$/, (result, [changesInsert, changesDelete, file]) => { + const insertions = asNumber(changesInsert); + const deletions = asNumber(changesDelete); + result.changed++; + result.insertions += insertions; + result.deletions += deletions; + result.files.push({ + file, + changes: insertions + deletions, + insertions, + deletions, + binary: false + }); + }), + new LineParser(/-\t-\t(.+)$/, (result, [file]) => { + result.changed++; + result.files.push({ + file, + after: 0, + before: 0, + binary: true + }); + }) + ]; + nameOnlyParser = [ + new LineParser(/(.+)$/, (result, [file]) => { + result.changed++; + result.files.push({ + file, + changes: 0, + insertions: 0, + deletions: 0, + binary: false + }); + }) + ]; + nameStatusParser = [ + new LineParser(/([ACDMRTUXB])([0-9][0-9][0-9])?\t(.[^\t]+)\t?(.*)?$/, (result, [status2, _similarity, from, to]) => { + result.changed++; + result.files.push({ + file: to != null ? to : from, + changes: 0, + status: status2, + insertions: 0, + deletions: 0, + binary: false + }); + }) + ]; + diffSummaryParsers = { + [ + "" + /* NONE */ + ]: statParser, + [ + "--stat" + /* STAT */ + ]: statParser, + [ + "--numstat" + /* NUM_STAT */ + ]: numStatParser, + [ + "--name-status" + /* NAME_STATUS */ + ]: nameStatusParser, + [ + "--name-only" + /* NAME_ONLY */ + ]: nameOnlyParser + }; + } +}); +function lineBuilder(tokens, fields) { + return fields.reduce((line, field, index2) => { + line[field] = tokens[index2] || ""; + return line; + }, /* @__PURE__ */ Object.create({ diff: null })); +} +function createListLogSummaryParser(splitter = SPLITTER, fields = defaultFieldNames, logFormat = "") { + const parseDiffResult = getDiffParser(logFormat); + return function(stdOut) { + const all = toLinesWithContent(stdOut, true, START_BOUNDARY).map(function(item) { + const lineDetail = item.trim().split(COMMIT_BOUNDARY); + const listLogLine = lineBuilder(lineDetail[0].trim().split(splitter), fields); + if (lineDetail.length > 1 && !!lineDetail[1].trim()) { + listLogLine.diff = parseDiffResult(lineDetail[1]); + } + return listLogLine; + }); + return { + all, + latest: all.length && all[0] || null, + total: all.length + }; + }; +} +var START_BOUNDARY; +var COMMIT_BOUNDARY; +var SPLITTER; +var defaultFieldNames; +var init_parse_list_log_summary = __esm2({ + "src/lib/parsers/parse-list-log-summary.ts"() { + init_utils(); + init_parse_diff_summary(); + init_log_format(); + START_BOUNDARY = "\xF2\xF2\xF2\xF2\xF2\xF2 "; + COMMIT_BOUNDARY = " \xF2\xF2"; + SPLITTER = " \xF2 "; + defaultFieldNames = ["hash", "date", "message", "refs", "author_name", "author_email"]; + } +}); +var diff_exports = {}; +__export2(diff_exports, { + diffSummaryTask: () => diffSummaryTask, + validateLogFormatConfig: () => validateLogFormatConfig +}); +function diffSummaryTask(customArgs) { + let logFormat = logFormatFromCommand(customArgs); + const commands2 = ["diff"]; + if (logFormat === "") { + logFormat = "--stat"; + commands2.push("--stat=4096"); + } + commands2.push(...customArgs); + return validateLogFormatConfig(commands2) || { + commands: commands2, + format: "utf-8", + parser: getDiffParser(logFormat) + }; +} +function validateLogFormatConfig(customArgs) { + const flags = customArgs.filter(isLogFormat); + if (flags.length > 1) { + return configurationErrorTask(`Summary flags are mutually exclusive - pick one of ${flags.join(",")}`); + } + if (flags.length && customArgs.includes("-z")) { + return configurationErrorTask(`Summary flag ${flags} parsing is not compatible with null termination option '-z'`); + } +} +var init_diff = __esm2({ + "src/lib/tasks/diff.ts"() { + init_log_format(); + init_parse_diff_summary(); + init_task(); + } +}); +function prettyFormat(format, splitter) { + const fields = []; + const formatStr = []; + Object.keys(format).forEach((field) => { + fields.push(field); + formatStr.push(String(format[field])); + }); + return [fields, formatStr.join(splitter)]; +} +function userOptions(input) { + return Object.keys(input).reduce((out, key2) => { + if (!(key2 in excludeOptions)) { + out[key2] = input[key2]; + } + return out; + }, {}); +} +function parseLogOptions(opt = {}, customArgs = []) { + const splitter = filterType(opt.splitter, filterString, SPLITTER); + const format = !filterPrimitives(opt.format) && opt.format ? opt.format : { + hash: "%H", + date: opt.strictDate === false ? "%ai" : "%aI", + message: "%s", + refs: "%D", + body: opt.multiLine ? "%B" : "%b", + author_name: opt.mailMap !== false ? "%aN" : "%an", + author_email: opt.mailMap !== false ? "%aE" : "%ae" + }; + const [fields, formatStr] = prettyFormat(format, splitter); + const suffix = []; + const command = [ + `--pretty=format:${START_BOUNDARY}${formatStr}${COMMIT_BOUNDARY}`, + ...customArgs + ]; + const maxCount = opt.n || opt["max-count"] || opt.maxCount; + if (maxCount) { + command.push(`--max-count=${maxCount}`); + } + if (opt.from || opt.to) { + const rangeOperator = opt.symmetric !== false ? "..." : ".."; + suffix.push(`${opt.from || ""}${rangeOperator}${opt.to || ""}`); + } + if (filterString(opt.file)) { + suffix.push("--follow", opt.file); + } + appendTaskOptions(userOptions(opt), command); + return { + fields, + splitter, + commands: [...command, ...suffix] + }; +} +function logTask(splitter, fields, customArgs) { + const parser3 = createListLogSummaryParser(splitter, fields, logFormatFromCommand(customArgs)); + return { + commands: ["log", ...customArgs], + format: "utf-8", + parser: parser3 + }; +} +function log_default() { + return { + log(...rest) { + const next = trailingFunctionArgument(arguments); + const options = parseLogOptions(trailingOptionsArgument(arguments), filterType(arguments[0], filterArray)); + const task = rejectDeprecatedSignatures(...rest) || validateLogFormatConfig(options.commands) || createLogTask(options); + return this._runTask(task, next); + } + }; + function createLogTask(options) { + return logTask(options.splitter, options.fields, options.commands); + } + function rejectDeprecatedSignatures(from, to) { + return filterString(from) && filterString(to) && configurationErrorTask(`git.log(string, string) should be replaced with git.log({ from: string, to: string })`); + } +} +var excludeOptions; +var init_log = __esm2({ + "src/lib/tasks/log.ts"() { + init_log_format(); + init_parse_list_log_summary(); + init_utils(); + init_task(); + init_diff(); + excludeOptions = /* @__PURE__ */ ((excludeOptions2) => { + excludeOptions2[excludeOptions2["--pretty"] = 0] = "--pretty"; + excludeOptions2[excludeOptions2["max-count"] = 1] = "max-count"; + excludeOptions2[excludeOptions2["maxCount"] = 2] = "maxCount"; + excludeOptions2[excludeOptions2["n"] = 3] = "n"; + excludeOptions2[excludeOptions2["file"] = 4] = "file"; + excludeOptions2[excludeOptions2["format"] = 5] = "format"; + excludeOptions2[excludeOptions2["from"] = 6] = "from"; + excludeOptions2[excludeOptions2["to"] = 7] = "to"; + excludeOptions2[excludeOptions2["splitter"] = 8] = "splitter"; + excludeOptions2[excludeOptions2["symmetric"] = 9] = "symmetric"; + excludeOptions2[excludeOptions2["mailMap"] = 10] = "mailMap"; + excludeOptions2[excludeOptions2["multiLine"] = 11] = "multiLine"; + excludeOptions2[excludeOptions2["strictDate"] = 12] = "strictDate"; + return excludeOptions2; + })(excludeOptions || {}); + } +}); +var MergeSummaryConflict; +var MergeSummaryDetail; +var init_MergeSummary = __esm2({ + "src/lib/responses/MergeSummary.ts"() { + MergeSummaryConflict = class { + constructor(reason, file = null, meta) { + this.reason = reason; + this.file = file; + this.meta = meta; + } + toString() { + return `${this.file}:${this.reason}`; + } + }; + MergeSummaryDetail = class { + constructor() { + this.conflicts = []; + this.merges = []; + this.result = "success"; + } + get failed() { + return this.conflicts.length > 0; + } + get reason() { + return this.result; + } + toString() { + if (this.conflicts.length) { + return `CONFLICTS: ${this.conflicts.join(", ")}`; + } + return "OK"; + } + }; + } +}); +var PullSummary; +var PullFailedSummary; +var init_PullSummary = __esm2({ + "src/lib/responses/PullSummary.ts"() { + PullSummary = class { + constructor() { + this.remoteMessages = { + all: [] + }; + this.created = []; + this.deleted = []; + this.files = []; + this.deletions = {}; + this.insertions = {}; + this.summary = { + changes: 0, + deletions: 0, + insertions: 0 + }; + } + }; + PullFailedSummary = class { + constructor() { + this.remote = ""; + this.hash = { + local: "", + remote: "" + }; + this.branch = { + local: "", + remote: "" + }; + this.message = ""; + } + toString() { + return this.message; + } + }; + } +}); +function objectEnumerationResult(remoteMessages) { + return remoteMessages.objects = remoteMessages.objects || { + compressing: 0, + counting: 0, + enumerating: 0, + packReused: 0, + reused: { count: 0, delta: 0 }, + total: { count: 0, delta: 0 } + }; +} +function asObjectCount(source) { + const count = /^\s*(\d+)/.exec(source); + const delta = /delta (\d+)/i.exec(source); + return { + count: asNumber(count && count[1] || "0"), + delta: asNumber(delta && delta[1] || "0") + }; +} +var remoteMessagesObjectParsers; +var init_parse_remote_objects = __esm2({ + "src/lib/parsers/parse-remote-objects.ts"() { + init_utils(); + remoteMessagesObjectParsers = [ + new RemoteLineParser(/^remote:\s*(enumerating|counting|compressing) objects: (\d+),/i, (result, [action, count]) => { + const key2 = action.toLowerCase(); + const enumeration = objectEnumerationResult(result.remoteMessages); + Object.assign(enumeration, { [key2]: asNumber(count) }); + }), + new RemoteLineParser(/^remote:\s*(enumerating|counting|compressing) objects: \d+% \(\d+\/(\d+)\),/i, (result, [action, count]) => { + const key2 = action.toLowerCase(); + const enumeration = objectEnumerationResult(result.remoteMessages); + Object.assign(enumeration, { [key2]: asNumber(count) }); + }), + new RemoteLineParser(/total ([^,]+), reused ([^,]+), pack-reused (\d+)/i, (result, [total, reused, packReused]) => { + const objects = objectEnumerationResult(result.remoteMessages); + objects.total = asObjectCount(total); + objects.reused = asObjectCount(reused); + objects.packReused = asNumber(packReused); + }) + ]; + } +}); +function parseRemoteMessages(_stdOut, stdErr) { + return parseStringResponse({ remoteMessages: new RemoteMessageSummary() }, parsers2, stdErr); +} +var parsers2; +var RemoteMessageSummary; +var init_parse_remote_messages = __esm2({ + "src/lib/parsers/parse-remote-messages.ts"() { + init_utils(); + init_parse_remote_objects(); + parsers2 = [ + new RemoteLineParser(/^remote:\s*(.+)$/, (result, [text2]) => { + result.remoteMessages.all.push(text2.trim()); + return false; + }), + ...remoteMessagesObjectParsers, + new RemoteLineParser([/create a (?:pull|merge) request/i, /\s(https?:\/\/\S+)$/], (result, [pullRequestUrl]) => { + result.remoteMessages.pullRequestUrl = pullRequestUrl; + }), + new RemoteLineParser([/found (\d+) vulnerabilities.+\(([^)]+)\)/i, /\s(https?:\/\/\S+)$/], (result, [count, summary, url]) => { + result.remoteMessages.vulnerabilities = { + count: asNumber(count), + summary, + url + }; + }) + ]; + RemoteMessageSummary = class { + constructor() { + this.all = []; + } + }; + } +}); +function parsePullErrorResult(stdOut, stdErr) { + const pullError = parseStringResponse(new PullFailedSummary(), errorParsers, [stdOut, stdErr]); + return pullError.message && pullError; +} +var FILE_UPDATE_REGEX; +var SUMMARY_REGEX; +var ACTION_REGEX; +var parsers3; +var errorParsers; +var parsePullDetail; +var parsePullResult; +var init_parse_pull = __esm2({ + "src/lib/parsers/parse-pull.ts"() { + init_PullSummary(); + init_utils(); + init_parse_remote_messages(); + FILE_UPDATE_REGEX = /^\s*(.+?)\s+\|\s+\d+\s*(\+*)(-*)/; + SUMMARY_REGEX = /(\d+)\D+((\d+)\D+\(\+\))?(\D+(\d+)\D+\(-\))?/; + ACTION_REGEX = /^(create|delete) mode \d+ (.+)/; + parsers3 = [ + new LineParser(FILE_UPDATE_REGEX, (result, [file, insertions, deletions]) => { + result.files.push(file); + if (insertions) { + result.insertions[file] = insertions.length; + } + if (deletions) { + result.deletions[file] = deletions.length; + } + }), + new LineParser(SUMMARY_REGEX, (result, [changes, , insertions, , deletions]) => { + if (insertions !== void 0 || deletions !== void 0) { + result.summary.changes = +changes || 0; + result.summary.insertions = +insertions || 0; + result.summary.deletions = +deletions || 0; + return true; + } + return false; + }), + new LineParser(ACTION_REGEX, (result, [action, file]) => { + append(result.files, file); + append(action === "create" ? result.created : result.deleted, file); + }) + ]; + errorParsers = [ + new LineParser(/^from\s(.+)$/i, (result, [remote]) => void (result.remote = remote)), + new LineParser(/^fatal:\s(.+)$/, (result, [message]) => void (result.message = message)), + new LineParser(/([a-z0-9]+)\.\.([a-z0-9]+)\s+(\S+)\s+->\s+(\S+)$/, (result, [hashLocal, hashRemote, branchLocal, branchRemote]) => { + result.branch.local = branchLocal; + result.hash.local = hashLocal; + result.branch.remote = branchRemote; + result.hash.remote = hashRemote; + }) + ]; + parsePullDetail = (stdOut, stdErr) => { + return parseStringResponse(new PullSummary(), parsers3, [stdOut, stdErr]); + }; + parsePullResult = (stdOut, stdErr) => { + return Object.assign(new PullSummary(), parsePullDetail(stdOut, stdErr), parseRemoteMessages(stdOut, stdErr)); + }; + } +}); +var parsers4; +var parseMergeResult; +var parseMergeDetail; +var init_parse_merge = __esm2({ + "src/lib/parsers/parse-merge.ts"() { + init_MergeSummary(); + init_utils(); + init_parse_pull(); + parsers4 = [ + new LineParser(/^Auto-merging\s+(.+)$/, (summary, [autoMerge]) => { + summary.merges.push(autoMerge); + }), + new LineParser(/^CONFLICT\s+\((.+)\): Merge conflict in (.+)$/, (summary, [reason, file]) => { + summary.conflicts.push(new MergeSummaryConflict(reason, file)); + }), + new LineParser(/^CONFLICT\s+\((.+\/delete)\): (.+) deleted in (.+) and/, (summary, [reason, file, deleteRef2]) => { + summary.conflicts.push(new MergeSummaryConflict(reason, file, { deleteRef: deleteRef2 })); + }), + new LineParser(/^CONFLICT\s+\((.+)\):/, (summary, [reason]) => { + summary.conflicts.push(new MergeSummaryConflict(reason, null)); + }), + new LineParser(/^Automatic merge failed;\s+(.+)$/, (summary, [result]) => { + summary.result = result; + }) + ]; + parseMergeResult = (stdOut, stdErr) => { + return Object.assign(parseMergeDetail(stdOut, stdErr), parsePullResult(stdOut, stdErr)); + }; + parseMergeDetail = (stdOut) => { + return parseStringResponse(new MergeSummaryDetail(), parsers4, stdOut); + }; + } +}); +function mergeTask(customArgs) { + if (!customArgs.length) { + return configurationErrorTask("Git.merge requires at least one option"); + } + return { + commands: ["merge", ...customArgs], + format: "utf-8", + parser(stdOut, stdErr) { + const merge2 = parseMergeResult(stdOut, stdErr); + if (merge2.failed) { + throw new GitResponseError(merge2); + } + return merge2; + } + }; +} +var init_merge = __esm2({ + "src/lib/tasks/merge.ts"() { + init_git_response_error(); + init_parse_merge(); + init_task(); + } +}); +function pushResultPushedItem(local, remote, status2) { + const deleted = status2.includes("deleted"); + const tag2 = status2.includes("tag") || /^refs\/tags/.test(local); + const alreadyUpdated = !status2.includes("new"); + return { + deleted, + tag: tag2, + branch: !tag2, + new: !alreadyUpdated, + alreadyUpdated, + local, + remote + }; +} +var parsers5; +var parsePushResult; +var parsePushDetail; +var init_parse_push = __esm2({ + "src/lib/parsers/parse-push.ts"() { + init_utils(); + init_parse_remote_messages(); + parsers5 = [ + new LineParser(/^Pushing to (.+)$/, (result, [repo]) => { + result.repo = repo; + }), + new LineParser(/^updating local tracking ref '(.+)'/, (result, [local]) => { + result.ref = __spreadProps(__spreadValues({}, result.ref || {}), { + local + }); + }), + new LineParser(/^[=*-]\s+([^:]+):(\S+)\s+\[(.+)]$/, (result, [local, remote, type]) => { + result.pushed.push(pushResultPushedItem(local, remote, type)); + }), + new LineParser(/^Branch '([^']+)' set up to track remote branch '([^']+)' from '([^']+)'/, (result, [local, remote, remoteName]) => { + result.branch = __spreadProps(__spreadValues({}, result.branch || {}), { + local, + remote, + remoteName + }); + }), + new LineParser(/^([^:]+):(\S+)\s+([a-z0-9]+)\.\.([a-z0-9]+)$/, (result, [local, remote, from, to]) => { + result.update = { + head: { + local, + remote + }, + hash: { + from, + to + } + }; + }) + ]; + parsePushResult = (stdOut, stdErr) => { + const pushDetail = parsePushDetail(stdOut, stdErr); + const responseDetail = parseRemoteMessages(stdOut, stdErr); + return __spreadValues(__spreadValues({}, pushDetail), responseDetail); + }; + parsePushDetail = (stdOut, stdErr) => { + return parseStringResponse({ pushed: [] }, parsers5, [stdOut, stdErr]); + }; + } +}); +var push_exports = {}; +__export2(push_exports, { + pushTagsTask: () => pushTagsTask, + pushTask: () => pushTask +}); +function pushTagsTask(ref = {}, customArgs) { + append(customArgs, "--tags"); + return pushTask(ref, customArgs); +} +function pushTask(ref = {}, customArgs) { + const commands2 = ["push", ...customArgs]; + if (ref.branch) { + commands2.splice(1, 0, ref.branch); + } + if (ref.remote) { + commands2.splice(1, 0, ref.remote); + } + remove2(commands2, "-v"); + append(commands2, "--verbose"); + append(commands2, "--porcelain"); + return { + commands: commands2, + format: "utf-8", + parser: parsePushResult + }; +} +var init_push = __esm2({ + "src/lib/tasks/push.ts"() { + init_parse_push(); + init_utils(); + } +}); +var fromPathRegex; +var FileStatusSummary; +var init_FileStatusSummary = __esm2({ + "src/lib/responses/FileStatusSummary.ts"() { + fromPathRegex = /^(.+) -> (.+)$/; + FileStatusSummary = class { + constructor(path2, index2, working_dir) { + this.path = path2; + this.index = index2; + this.working_dir = working_dir; + if (index2 + working_dir === "R") { + const detail = fromPathRegex.exec(path2) || [null, path2, path2]; + this.from = detail[1] || ""; + this.path = detail[2] || ""; + } + } + }; + } +}); +function renamedFile(line) { + const [to, from] = line.split(NULL); + return { + from: from || to, + to + }; +} +function parser2(indexX, indexY, handler) { + return [`${indexX}${indexY}`, handler]; +} +function conflicts(indexX, ...indexY) { + return indexY.map((y) => parser2(indexX, y, (result, file) => append(result.conflicted, file))); +} +function splitLine(result, lineStr) { + const trimmed2 = lineStr.trim(); + switch (" ") { + case trimmed2.charAt(2): + return data(trimmed2.charAt(0), trimmed2.charAt(1), trimmed2.substr(3)); + case trimmed2.charAt(1): + return data(" ", trimmed2.charAt(0), trimmed2.substr(2)); + default: + return; + } + function data(index2, workingDir, path2) { + const raw = `${index2}${workingDir}`; + const handler = parsers6.get(raw); + if (handler) { + handler(result, path2); + } + if (raw !== "##" && raw !== "!!") { + result.files.push(new FileStatusSummary(path2.replace(/\0.+$/, ""), index2, workingDir)); + } + } +} +var StatusSummary; +var parsers6; +var parseStatusSummary; +var init_StatusSummary = __esm2({ + "src/lib/responses/StatusSummary.ts"() { + init_utils(); + init_FileStatusSummary(); + StatusSummary = class { + constructor() { + this.not_added = []; + this.conflicted = []; + this.created = []; + this.deleted = []; + this.ignored = void 0; + this.modified = []; + this.renamed = []; + this.files = []; + this.staged = []; + this.ahead = 0; + this.behind = 0; + this.current = null; + this.tracking = null; + this.detached = false; + this.isClean = () => { + return !this.files.length; + }; + } + }; + parsers6 = new Map([ + parser2(" ", "A", (result, file) => append(result.created, file)), + parser2(" ", "D", (result, file) => append(result.deleted, file)), + parser2(" ", "M", (result, file) => append(result.modified, file)), + parser2("A", " ", (result, file) => append(result.created, file) && append(result.staged, file)), + parser2("A", "M", (result, file) => append(result.created, file) && append(result.staged, file) && append(result.modified, file)), + parser2("D", " ", (result, file) => append(result.deleted, file) && append(result.staged, file)), + parser2("M", " ", (result, file) => append(result.modified, file) && append(result.staged, file)), + parser2("M", "M", (result, file) => append(result.modified, file) && append(result.staged, file)), + parser2("R", " ", (result, file) => { + append(result.renamed, renamedFile(file)); + }), + parser2("R", "M", (result, file) => { + const renamed = renamedFile(file); + append(result.renamed, renamed); + append(result.modified, renamed.to); + }), + parser2("!", "!", (_result, _file) => { + append(_result.ignored = _result.ignored || [], _file); + }), + parser2("?", "?", (result, file) => append(result.not_added, file)), + ...conflicts( + "A", + "A", + "U" + /* UNMERGED */ + ), + ...conflicts( + "D", + "D", + "U" + /* UNMERGED */ + ), + ...conflicts( + "U", + "A", + "D", + "U" + /* UNMERGED */ + ), + [ + "##", + (result, line) => { + const aheadReg = /ahead (\d+)/; + const behindReg = /behind (\d+)/; + const currentReg = /^(.+?(?=(?:\.{3}|\s|$)))/; + const trackingReg = /\.{3}(\S*)/; + const onEmptyBranchReg = /\son\s([\S]+)$/; + let regexResult; + regexResult = aheadReg.exec(line); + result.ahead = regexResult && +regexResult[1] || 0; + regexResult = behindReg.exec(line); + result.behind = regexResult && +regexResult[1] || 0; + regexResult = currentReg.exec(line); + result.current = regexResult && regexResult[1]; + regexResult = trackingReg.exec(line); + result.tracking = regexResult && regexResult[1]; + regexResult = onEmptyBranchReg.exec(line); + result.current = regexResult && regexResult[1] || result.current; + result.detached = /\(no branch\)/.test(line); + } + ] + ]); + parseStatusSummary = function(text2) { + const lines = text2.split(NULL); + const status2 = new StatusSummary(); + for (let i = 0, l = lines.length; i < l; ) { + let line = lines[i++].trim(); + if (!line) { + continue; + } + if (line.charAt(0) === "R") { + line += NULL + (lines[i++] || ""); + } + splitLine(status2, line); + } + return status2; + }; + } +}); +function statusTask(customArgs) { + const commands2 = [ + "status", + "--porcelain", + "-b", + "-u", + "--null", + ...customArgs.filter((arg) => !ignoredOptions.includes(arg)) + ]; + return { + format: "utf-8", + commands: commands2, + parser(text2) { + return parseStatusSummary(text2); + } + }; +} +var ignoredOptions; +var init_status = __esm2({ + "src/lib/tasks/status.ts"() { + init_StatusSummary(); + ignoredOptions = ["--null", "-z"]; + } +}); +function versionResponse(major = 0, minor = 0, patch = 0, agent = "", installed = true) { + return Object.defineProperty({ + major, + minor, + patch, + agent, + installed + }, "toString", { + value() { + return `${this.major}.${this.minor}.${this.patch}`; + }, + configurable: false, + enumerable: false + }); +} +function notInstalledResponse() { + return versionResponse(0, 0, 0, "", false); +} +function version_default() { + return { + version() { + return this._runTask({ + commands: ["--version"], + format: "utf-8", + parser: versionParser, + onError(result, error, done, fail) { + if (result.exitCode === -2) { + return done(Buffer.from(NOT_INSTALLED)); + } + fail(error); + } + }); + } + }; +} +function versionParser(stdOut) { + if (stdOut === NOT_INSTALLED) { + return notInstalledResponse(); + } + return parseStringResponse(versionResponse(0, 0, 0, stdOut), parsers7, stdOut); +} +var NOT_INSTALLED; +var parsers7; +var init_version = __esm2({ + "src/lib/tasks/version.ts"() { + init_utils(); + NOT_INSTALLED = "installed=false"; + parsers7 = [ + new LineParser(/version (\d+)\.(\d+)\.(\d+)(?:\s*\((.+)\))?/, (result, [major, minor, patch, agent = ""]) => { + Object.assign(result, versionResponse(asNumber(major), asNumber(minor), asNumber(patch), agent)); + }), + new LineParser(/version (\d+)\.(\d+)\.(\D+)(.+)?$/, (result, [major, minor, patch, agent = ""]) => { + Object.assign(result, versionResponse(asNumber(major), asNumber(minor), patch, agent)); + }) + ]; + } +}); +var simple_git_api_exports = {}; +__export2(simple_git_api_exports, { + SimpleGitApi: () => SimpleGitApi +}); +var SimpleGitApi; +var init_simple_git_api = __esm2({ + "src/lib/simple-git-api.ts"() { + init_task_callback(); + init_change_working_directory(); + init_checkout(); + init_commit(); + init_config(); + init_grep(); + init_hash_object(); + init_init(); + init_log(); + init_merge(); + init_push(); + init_status(); + init_task(); + init_version(); + init_utils(); + SimpleGitApi = class { + constructor(_executor) { + this._executor = _executor; + } + _runTask(task, then) { + const chain = this._executor.chain(); + const promise2 = chain.push(task); + if (then) { + taskCallback(task, promise2, then); + } + return Object.create(this, { + then: { value: promise2.then.bind(promise2) }, + catch: { value: promise2.catch.bind(promise2) }, + _executor: { value: chain } + }); + } + add(files) { + return this._runTask(straightThroughStringTask(["add", ...asArray(files)]), trailingFunctionArgument(arguments)); + } + cwd(directory) { + const next = trailingFunctionArgument(arguments); + if (typeof directory === "string") { + return this._runTask(changeWorkingDirectoryTask(directory, this._executor), next); + } + if (typeof (directory == null ? void 0 : directory.path) === "string") { + return this._runTask(changeWorkingDirectoryTask(directory.path, directory.root && this._executor || void 0), next); + } + return this._runTask(configurationErrorTask("Git.cwd: workingDirectory must be supplied as a string"), next); + } + hashObject(path2, write) { + return this._runTask(hashObjectTask(path2, write === true), trailingFunctionArgument(arguments)); + } + init(bare) { + return this._runTask(initTask(bare === true, this._executor.cwd, getTrailingOptions(arguments)), trailingFunctionArgument(arguments)); + } + merge() { + return this._runTask(mergeTask(getTrailingOptions(arguments)), trailingFunctionArgument(arguments)); + } + mergeFromTo(remote, branch2) { + if (!(filterString(remote) && filterString(branch2))) { + return this._runTask(configurationErrorTask(`Git.mergeFromTo requires that the 'remote' and 'branch' arguments are supplied as strings`)); + } + return this._runTask(mergeTask([remote, branch2, ...getTrailingOptions(arguments)]), trailingFunctionArgument(arguments, false)); + } + outputHandler(handler) { + this._executor.outputHandler = handler; + return this; + } + push() { + const task = pushTask({ + remote: filterType(arguments[0], filterString), + branch: filterType(arguments[1], filterString) + }, getTrailingOptions(arguments)); + return this._runTask(task, trailingFunctionArgument(arguments)); + } + stash() { + return this._runTask(straightThroughStringTask(["stash", ...getTrailingOptions(arguments)]), trailingFunctionArgument(arguments)); + } + status() { + return this._runTask(statusTask(getTrailingOptions(arguments)), trailingFunctionArgument(arguments)); + } + }; + Object.assign(SimpleGitApi.prototype, checkout_default(), commit_default(), config_default(), grep_default(), log_default(), version_default()); + } +}); +var scheduler_exports = {}; +__export2(scheduler_exports, { + Scheduler: () => Scheduler +}); +var createScheduledTask; +var Scheduler; +var init_scheduler = __esm2({ + "src/lib/runners/scheduler.ts"() { + init_utils(); + init_git_logger(); + createScheduledTask = (() => { + let id = 0; + return () => { + id++; + const { promise: promise2, done } = (0, import_promise_deferred.createDeferred)(); + return { + promise: promise2, + done, + id + }; + }; + })(); + Scheduler = class { + constructor(concurrency = 2) { + this.concurrency = concurrency; + this.logger = createLogger("", "scheduler"); + this.pending = []; + this.running = []; + this.logger(`Constructed, concurrency=%s`, concurrency); + } + schedule() { + if (!this.pending.length || this.running.length >= this.concurrency) { + this.logger(`Schedule attempt ignored, pending=%s running=%s concurrency=%s`, this.pending.length, this.running.length, this.concurrency); + return; + } + const task = append(this.running, this.pending.shift()); + this.logger(`Attempting id=%s`, task.id); + task.done(() => { + this.logger(`Completing id=`, task.id); + remove2(this.running, task); + this.schedule(); + }); + } + next() { + const { promise: promise2, id } = append(this.pending, createScheduledTask()); + this.logger(`Scheduling id=%s`, id); + this.schedule(); + return promise2; + } + }; + } +}); +var apply_patch_exports = {}; +__export2(apply_patch_exports, { + applyPatchTask: () => applyPatchTask +}); +function applyPatchTask(patches, customArgs) { + return straightThroughStringTask(["apply", ...customArgs, ...patches]); +} +var init_apply_patch = __esm2({ + "src/lib/tasks/apply-patch.ts"() { + init_task(); + } +}); +function branchDeletionSuccess(branch2, hash2) { + return { + branch: branch2, + hash: hash2, + success: true + }; +} +function branchDeletionFailure(branch2) { + return { + branch: branch2, + hash: null, + success: false + }; +} +var BranchDeletionBatch; +var init_BranchDeleteSummary = __esm2({ + "src/lib/responses/BranchDeleteSummary.ts"() { + BranchDeletionBatch = class { + constructor() { + this.all = []; + this.branches = {}; + this.errors = []; + } + get success() { + return !this.errors.length; + } + }; + } +}); +function hasBranchDeletionError(data, processExitCode) { + return processExitCode === 1 && deleteErrorRegex.test(data); +} +var deleteSuccessRegex; +var deleteErrorRegex; +var parsers8; +var parseBranchDeletions; +var init_parse_branch_delete = __esm2({ + "src/lib/parsers/parse-branch-delete.ts"() { + init_BranchDeleteSummary(); + init_utils(); + deleteSuccessRegex = /(\S+)\s+\(\S+\s([^)]+)\)/; + deleteErrorRegex = /^error[^']+'([^']+)'/m; + parsers8 = [ + new LineParser(deleteSuccessRegex, (result, [branch2, hash2]) => { + const deletion = branchDeletionSuccess(branch2, hash2); + result.all.push(deletion); + result.branches[branch2] = deletion; + }), + new LineParser(deleteErrorRegex, (result, [branch2]) => { + const deletion = branchDeletionFailure(branch2); + result.errors.push(deletion); + result.all.push(deletion); + result.branches[branch2] = deletion; + }) + ]; + parseBranchDeletions = (stdOut, stdErr) => { + return parseStringResponse(new BranchDeletionBatch(), parsers8, [stdOut, stdErr]); + }; + } +}); +var BranchSummaryResult; +var init_BranchSummary = __esm2({ + "src/lib/responses/BranchSummary.ts"() { + BranchSummaryResult = class { + constructor() { + this.all = []; + this.branches = {}; + this.current = ""; + this.detached = false; + } + push(status2, detached, name, commit2, label) { + if (status2 === "*") { + this.detached = detached; + this.current = name; + } + this.all.push(name); + this.branches[name] = { + current: status2 === "*", + linkedWorkTree: status2 === "+", + name, + commit: commit2, + label + }; + } + }; + } +}); +function branchStatus(input) { + return input ? input.charAt(0) : ""; +} +function parseBranchSummary(stdOut) { + return parseStringResponse(new BranchSummaryResult(), parsers9, stdOut); +} +var parsers9; +var init_parse_branch = __esm2({ + "src/lib/parsers/parse-branch.ts"() { + init_BranchSummary(); + init_utils(); + parsers9 = [ + new LineParser(/^([*+]\s)?\((?:HEAD )?detached (?:from|at) (\S+)\)\s+([a-z0-9]+)\s(.*)$/, (result, [current, name, commit2, label]) => { + result.push(branchStatus(current), true, name, commit2, label); + }), + new LineParser(/^([*+]\s)?(\S+)\s+([a-z0-9]+)\s?(.*)$/s, (result, [current, name, commit2, label]) => { + result.push(branchStatus(current), false, name, commit2, label); + }) + ]; + } +}); +var branch_exports = {}; +__export2(branch_exports, { + branchLocalTask: () => branchLocalTask, + branchTask: () => branchTask, + containsDeleteBranchCommand: () => containsDeleteBranchCommand, + deleteBranchTask: () => deleteBranchTask, + deleteBranchesTask: () => deleteBranchesTask +}); +function containsDeleteBranchCommand(commands2) { + const deleteCommands = ["-d", "-D", "--delete"]; + return commands2.some((command) => deleteCommands.includes(command)); +} +function branchTask(customArgs) { + const isDelete = containsDeleteBranchCommand(customArgs); + const commands2 = ["branch", ...customArgs]; + if (commands2.length === 1) { + commands2.push("-a"); + } + if (!commands2.includes("-v")) { + commands2.splice(1, 0, "-v"); + } + return { + format: "utf-8", + commands: commands2, + parser(stdOut, stdErr) { + if (isDelete) { + return parseBranchDeletions(stdOut, stdErr).all[0]; + } + return parseBranchSummary(stdOut); + } + }; +} +function branchLocalTask() { + const parser3 = parseBranchSummary; + return { + format: "utf-8", + commands: ["branch", "-v"], + parser: parser3 + }; +} +function deleteBranchesTask(branches, forceDelete = false) { + return { + format: "utf-8", + commands: ["branch", "-v", forceDelete ? "-D" : "-d", ...branches], + parser(stdOut, stdErr) { + return parseBranchDeletions(stdOut, stdErr); + }, + onError({ exitCode, stdOut }, error, done, fail) { + if (!hasBranchDeletionError(String(error), exitCode)) { + return fail(error); + } + done(stdOut); + } + }; +} +function deleteBranchTask(branch2, forceDelete = false) { + const task = { + format: "utf-8", + commands: ["branch", "-v", forceDelete ? "-D" : "-d", branch2], + parser(stdOut, stdErr) { + return parseBranchDeletions(stdOut, stdErr).branches[branch2]; + }, + onError({ exitCode, stdErr, stdOut }, error, _, fail) { + if (!hasBranchDeletionError(String(error), exitCode)) { + return fail(error); + } + throw new GitResponseError(task.parser(bufferToString(stdOut), bufferToString(stdErr)), String(error)); + } + }; + return task; +} +var init_branch = __esm2({ + "src/lib/tasks/branch.ts"() { + init_git_response_error(); + init_parse_branch_delete(); + init_parse_branch(); + init_utils(); + } +}); +var parseCheckIgnore; +var init_CheckIgnore = __esm2({ + "src/lib/responses/CheckIgnore.ts"() { + parseCheckIgnore = (text2) => { + return text2.split(/\n/g).map((line) => line.trim()).filter((file) => !!file); + }; + } +}); +var check_ignore_exports = {}; +__export2(check_ignore_exports, { + checkIgnoreTask: () => checkIgnoreTask +}); +function checkIgnoreTask(paths) { + return { + commands: ["check-ignore", ...paths], + format: "utf-8", + parser: parseCheckIgnore + }; +} +var init_check_ignore = __esm2({ + "src/lib/tasks/check-ignore.ts"() { + init_CheckIgnore(); + } +}); +var clone_exports = {}; +__export2(clone_exports, { + cloneMirrorTask: () => cloneMirrorTask, + cloneTask: () => cloneTask +}); +function disallowedCommand(command) { + return /^--upload-pack(=|$)/.test(command); +} +function cloneTask(repo, directory, customArgs) { + const commands2 = ["clone", ...customArgs]; + filterString(repo) && commands2.push(repo); + filterString(directory) && commands2.push(directory); + const banned = commands2.find(disallowedCommand); + if (banned) { + return configurationErrorTask(`git.fetch: potential exploit argument blocked.`); + } + return straightThroughStringTask(commands2); +} +function cloneMirrorTask(repo, directory, customArgs) { + append(customArgs, "--mirror"); + return cloneTask(repo, directory, customArgs); +} +var init_clone = __esm2({ + "src/lib/tasks/clone.ts"() { + init_task(); + init_utils(); + } +}); +function parseFetchResult(stdOut, stdErr) { + const result = { + raw: stdOut, + remote: null, + branches: [], + tags: [], + updated: [], + deleted: [] + }; + return parseStringResponse(result, parsers10, [stdOut, stdErr]); +} +var parsers10; +var init_parse_fetch = __esm2({ + "src/lib/parsers/parse-fetch.ts"() { + init_utils(); + parsers10 = [ + new LineParser(/From (.+)$/, (result, [remote]) => { + result.remote = remote; + }), + new LineParser(/\* \[new branch]\s+(\S+)\s*-> (.+)$/, (result, [name, tracking]) => { + result.branches.push({ + name, + tracking + }); + }), + new LineParser(/\* \[new tag]\s+(\S+)\s*-> (.+)$/, (result, [name, tracking]) => { + result.tags.push({ + name, + tracking + }); + }), + new LineParser(/- \[deleted]\s+\S+\s*-> (.+)$/, (result, [tracking]) => { + result.deleted.push({ + tracking + }); + }), + new LineParser(/\s*([^.]+)\.\.(\S+)\s+(\S+)\s*-> (.+)$/, (result, [from, to, name, tracking]) => { + result.updated.push({ + name, + tracking, + to, + from + }); + }) + ]; + } +}); +var fetch_exports = {}; +__export2(fetch_exports, { + fetchTask: () => fetchTask +}); +function disallowedCommand2(command) { + return /^--upload-pack(=|$)/.test(command); +} +function fetchTask(remote, branch2, customArgs) { + const commands2 = ["fetch", ...customArgs]; + if (remote && branch2) { + commands2.push(remote, branch2); + } + const banned = commands2.find(disallowedCommand2); + if (banned) { + return configurationErrorTask(`git.fetch: potential exploit argument blocked.`); + } + return { + commands: commands2, + format: "utf-8", + parser: parseFetchResult + }; +} +var init_fetch = __esm2({ + "src/lib/tasks/fetch.ts"() { + init_parse_fetch(); + init_task(); + } +}); +function parseMoveResult(stdOut) { + return parseStringResponse({ moves: [] }, parsers11, stdOut); +} +var parsers11; +var init_parse_move = __esm2({ + "src/lib/parsers/parse-move.ts"() { + init_utils(); + parsers11 = [ + new LineParser(/^Renaming (.+) to (.+)$/, (result, [from, to]) => { + result.moves.push({ from, to }); + }) + ]; + } +}); +var move_exports = {}; +__export2(move_exports, { + moveTask: () => moveTask +}); +function moveTask(from, to) { + return { + commands: ["mv", "-v", ...asArray(from), to], + format: "utf-8", + parser: parseMoveResult + }; +} +var init_move = __esm2({ + "src/lib/tasks/move.ts"() { + init_parse_move(); + init_utils(); + } +}); +var pull_exports = {}; +__export2(pull_exports, { + pullTask: () => pullTask +}); +function pullTask(remote, branch2, customArgs) { + const commands2 = ["pull", ...customArgs]; + if (remote && branch2) { + commands2.splice(1, 0, remote, branch2); + } + return { + commands: commands2, + format: "utf-8", + parser(stdOut, stdErr) { + return parsePullResult(stdOut, stdErr); + }, + onError(result, _error, _done, fail) { + const pullError = parsePullErrorResult(bufferToString(result.stdOut), bufferToString(result.stdErr)); + if (pullError) { + return fail(new GitResponseError(pullError)); + } + fail(_error); + } + }; +} +var init_pull = __esm2({ + "src/lib/tasks/pull.ts"() { + init_git_response_error(); + init_parse_pull(); + init_utils(); + } +}); +function parseGetRemotes(text2) { + const remotes = {}; + forEach(text2, ([name]) => remotes[name] = { name }); + return Object.values(remotes); +} +function parseGetRemotesVerbose(text2) { + const remotes = {}; + forEach(text2, ([name, url, purpose]) => { + if (!remotes.hasOwnProperty(name)) { + remotes[name] = { + name, + refs: { fetch: "", push: "" } + }; + } + if (purpose && url) { + remotes[name].refs[purpose.replace(/[^a-z]/g, "")] = url; + } + }); + return Object.values(remotes); +} +function forEach(text2, handler) { + forEachLineWithContent(text2, (line) => handler(line.split(/\s+/))); +} +var init_GetRemoteSummary = __esm2({ + "src/lib/responses/GetRemoteSummary.ts"() { + init_utils(); + } +}); +var remote_exports = {}; +__export2(remote_exports, { + addRemoteTask: () => addRemoteTask, + getRemotesTask: () => getRemotesTask, + listRemotesTask: () => listRemotesTask, + remoteTask: () => remoteTask, + removeRemoteTask: () => removeRemoteTask +}); +function addRemoteTask(remoteName, remoteRepo, customArgs = []) { + return straightThroughStringTask(["remote", "add", ...customArgs, remoteName, remoteRepo]); +} +function getRemotesTask(verbose) { + const commands2 = ["remote"]; + if (verbose) { + commands2.push("-v"); + } + return { + commands: commands2, + format: "utf-8", + parser: verbose ? parseGetRemotesVerbose : parseGetRemotes + }; +} +function listRemotesTask(customArgs = []) { + const commands2 = [...customArgs]; + if (commands2[0] !== "ls-remote") { + commands2.unshift("ls-remote"); + } + return straightThroughStringTask(commands2); +} +function remoteTask(customArgs = []) { + const commands2 = [...customArgs]; + if (commands2[0] !== "remote") { + commands2.unshift("remote"); + } + return straightThroughStringTask(commands2); +} +function removeRemoteTask(remoteName) { + return straightThroughStringTask(["remote", "remove", remoteName]); +} +var init_remote = __esm2({ + "src/lib/tasks/remote.ts"() { + init_GetRemoteSummary(); + init_task(); + } +}); +var stash_list_exports = {}; +__export2(stash_list_exports, { + stashListTask: () => stashListTask +}); +function stashListTask(opt = {}, customArgs) { + const options = parseLogOptions(opt); + const commands2 = ["stash", "list", ...options.commands, ...customArgs]; + const parser3 = createListLogSummaryParser(options.splitter, options.fields, logFormatFromCommand(commands2)); + return validateLogFormatConfig(commands2) || { + commands: commands2, + format: "utf-8", + parser: parser3 + }; +} +var init_stash_list = __esm2({ + "src/lib/tasks/stash-list.ts"() { + init_log_format(); + init_parse_list_log_summary(); + init_diff(); + init_log(); + } +}); +var sub_module_exports = {}; +__export2(sub_module_exports, { + addSubModuleTask: () => addSubModuleTask, + initSubModuleTask: () => initSubModuleTask, + subModuleTask: () => subModuleTask, + updateSubModuleTask: () => updateSubModuleTask +}); +function addSubModuleTask(repo, path2) { + return subModuleTask(["add", repo, path2]); +} +function initSubModuleTask(customArgs) { + return subModuleTask(["init", ...customArgs]); +} +function subModuleTask(customArgs) { + const commands2 = [...customArgs]; + if (commands2[0] !== "submodule") { + commands2.unshift("submodule"); + } + return straightThroughStringTask(commands2); +} +function updateSubModuleTask(customArgs) { + return subModuleTask(["update", ...customArgs]); +} +var init_sub_module = __esm2({ + "src/lib/tasks/sub-module.ts"() { + init_task(); + } +}); +function singleSorted(a, b) { + const aIsNum = isNaN(a); + const bIsNum = isNaN(b); + if (aIsNum !== bIsNum) { + return aIsNum ? 1 : -1; + } + return aIsNum ? sorted(a, b) : 0; +} +function sorted(a, b) { + return a === b ? 0 : a > b ? 1 : -1; +} +function trimmed(input) { + return input.trim(); +} +function toNumber(input) { + if (typeof input === "string") { + return parseInt(input.replace(/^\D+/g, ""), 10) || 0; + } + return 0; +} +var TagList; +var parseTagList; +var init_TagList = __esm2({ + "src/lib/responses/TagList.ts"() { + TagList = class { + constructor(all, latest) { + this.all = all; + this.latest = latest; + } + }; + parseTagList = function(data, customSort = false) { + const tags = data.split("\n").map(trimmed).filter(Boolean); + if (!customSort) { + tags.sort(function(tagA, tagB) { + const partsA = tagA.split("."); + const partsB = tagB.split("."); + if (partsA.length === 1 || partsB.length === 1) { + return singleSorted(toNumber(partsA[0]), toNumber(partsB[0])); + } + for (let i = 0, l = Math.max(partsA.length, partsB.length); i < l; i++) { + const diff2 = sorted(toNumber(partsA[i]), toNumber(partsB[i])); + if (diff2) { + return diff2; + } + } + return 0; + }); + } + const latest = customSort ? tags[0] : [...tags].reverse().find((tag2) => tag2.indexOf(".") >= 0); + return new TagList(tags, latest); + }; + } +}); +var tag_exports = {}; +__export2(tag_exports, { + addAnnotatedTagTask: () => addAnnotatedTagTask, + addTagTask: () => addTagTask, + tagListTask: () => tagListTask +}); +function tagListTask(customArgs = []) { + const hasCustomSort = customArgs.some((option) => /^--sort=/.test(option)); + return { + format: "utf-8", + commands: ["tag", "-l", ...customArgs], + parser(text2) { + return parseTagList(text2, hasCustomSort); + } + }; +} +function addTagTask(name) { + return { + format: "utf-8", + commands: ["tag", name], + parser() { + return { name }; + } + }; +} +function addAnnotatedTagTask(name, tagMessage) { + return { + format: "utf-8", + commands: ["tag", "-a", "-m", tagMessage, name], + parser() { + return { name }; + } + }; +} +var init_tag = __esm2({ + "src/lib/tasks/tag.ts"() { + init_TagList(); + } +}); +var require_git = __commonJS2({ + "src/git.js"(exports2, module2) { + var { GitExecutor: GitExecutor2 } = (init_git_executor(), __toCommonJS2(git_executor_exports)); + var { SimpleGitApi: SimpleGitApi2 } = (init_simple_git_api(), __toCommonJS2(simple_git_api_exports)); + var { Scheduler: Scheduler2 } = (init_scheduler(), __toCommonJS2(scheduler_exports)); + var { configurationErrorTask: configurationErrorTask2 } = (init_task(), __toCommonJS2(task_exports)); + var { + asArray: asArray2, + filterArray: filterArray2, + filterPrimitives: filterPrimitives2, + filterString: filterString2, + filterStringOrStringArray: filterStringOrStringArray2, + filterType: filterType2, + getTrailingOptions: getTrailingOptions2, + trailingFunctionArgument: trailingFunctionArgument2, + trailingOptionsArgument: trailingOptionsArgument2 + } = (init_utils(), __toCommonJS2(utils_exports)); + var { applyPatchTask: applyPatchTask2 } = (init_apply_patch(), __toCommonJS2(apply_patch_exports)); + var { + branchTask: branchTask2, + branchLocalTask: branchLocalTask2, + deleteBranchesTask: deleteBranchesTask2, + deleteBranchTask: deleteBranchTask2 + } = (init_branch(), __toCommonJS2(branch_exports)); + var { checkIgnoreTask: checkIgnoreTask2 } = (init_check_ignore(), __toCommonJS2(check_ignore_exports)); + var { checkIsRepoTask: checkIsRepoTask2 } = (init_check_is_repo(), __toCommonJS2(check_is_repo_exports)); + var { cloneTask: cloneTask2, cloneMirrorTask: cloneMirrorTask2 } = (init_clone(), __toCommonJS2(clone_exports)); + var { cleanWithOptionsTask: cleanWithOptionsTask2, isCleanOptionsArray: isCleanOptionsArray2 } = (init_clean(), __toCommonJS2(clean_exports)); + var { diffSummaryTask: diffSummaryTask2 } = (init_diff(), __toCommonJS2(diff_exports)); + var { fetchTask: fetchTask2 } = (init_fetch(), __toCommonJS2(fetch_exports)); + var { moveTask: moveTask2 } = (init_move(), __toCommonJS2(move_exports)); + var { pullTask: pullTask2 } = (init_pull(), __toCommonJS2(pull_exports)); + var { pushTagsTask: pushTagsTask2 } = (init_push(), __toCommonJS2(push_exports)); + var { + addRemoteTask: addRemoteTask2, + getRemotesTask: getRemotesTask2, + listRemotesTask: listRemotesTask2, + remoteTask: remoteTask2, + removeRemoteTask: removeRemoteTask2 + } = (init_remote(), __toCommonJS2(remote_exports)); + var { getResetMode: getResetMode2, resetTask: resetTask2 } = (init_reset(), __toCommonJS2(reset_exports)); + var { stashListTask: stashListTask2 } = (init_stash_list(), __toCommonJS2(stash_list_exports)); + var { + addSubModuleTask: addSubModuleTask2, + initSubModuleTask: initSubModuleTask2, + subModuleTask: subModuleTask2, + updateSubModuleTask: updateSubModuleTask2 + } = (init_sub_module(), __toCommonJS2(sub_module_exports)); + var { addAnnotatedTagTask: addAnnotatedTagTask2, addTagTask: addTagTask2, tagListTask: tagListTask2 } = (init_tag(), __toCommonJS2(tag_exports)); + var { straightThroughBufferTask: straightThroughBufferTask2, straightThroughStringTask: straightThroughStringTask2 } = (init_task(), __toCommonJS2(task_exports)); + function Git2(options, plugins) { + this._executor = new GitExecutor2(options.binary, options.baseDir, new Scheduler2(options.maxConcurrentProcesses), plugins); + this._trimmed = options.trimmed; + } + (Git2.prototype = Object.create(SimpleGitApi2.prototype)).constructor = Git2; + Git2.prototype.customBinary = function(command) { + this._executor.binary = command; + return this; + }; + Git2.prototype.env = function(name, value) { + if (arguments.length === 1 && typeof name === "object") { + this._executor.env = name; + } else { + (this._executor.env = this._executor.env || {})[name] = value; + } + return this; + }; + Git2.prototype.stashList = function(options) { + return this._runTask(stashListTask2(trailingOptionsArgument2(arguments) || {}, filterArray2(options) && options || []), trailingFunctionArgument2(arguments)); + }; + function createCloneTask(api, task, repoPath, localPath) { + if (typeof repoPath !== "string") { + return configurationErrorTask2(`git.${api}() requires a string 'repoPath'`); + } + return task(repoPath, filterType2(localPath, filterString2), getTrailingOptions2(arguments)); + } + Git2.prototype.clone = function() { + return this._runTask(createCloneTask("clone", cloneTask2, ...arguments), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.mirror = function() { + return this._runTask(createCloneTask("mirror", cloneMirrorTask2, ...arguments), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.mv = function(from, to) { + return this._runTask(moveTask2(from, to), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.checkoutLatestTag = function(then) { + var git = this; + return this.pull(function() { + git.tags(function(err, tags) { + git.checkout(tags.latest, then); + }); + }); + }; + Git2.prototype.pull = function(remote, branch2, options, then) { + return this._runTask(pullTask2(filterType2(remote, filterString2), filterType2(branch2, filterString2), getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.fetch = function(remote, branch2) { + return this._runTask(fetchTask2(filterType2(remote, filterString2), filterType2(branch2, filterString2), getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.silent = function(silence) { + console.warn("simple-git deprecation notice: git.silent: logging should be configured using the `debug` library / `DEBUG` environment variable, this will be an error in version 3"); + return this; + }; + Git2.prototype.tags = function(options, then) { + return this._runTask(tagListTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.rebase = function() { + return this._runTask(straightThroughStringTask2(["rebase", ...getTrailingOptions2(arguments)]), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.reset = function(mode) { + return this._runTask(resetTask2(getResetMode2(mode), getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.revert = function(commit2) { + const next = trailingFunctionArgument2(arguments); + if (typeof commit2 !== "string") { + return this._runTask(configurationErrorTask2("Commit must be a string"), next); + } + return this._runTask(straightThroughStringTask2(["revert", ...getTrailingOptions2(arguments, 0, true), commit2]), next); + }; + Git2.prototype.addTag = function(name) { + const task = typeof name === "string" ? addTagTask2(name) : configurationErrorTask2("Git.addTag requires a tag name"); + return this._runTask(task, trailingFunctionArgument2(arguments)); + }; + Git2.prototype.addAnnotatedTag = function(tagName, tagMessage) { + return this._runTask(addAnnotatedTagTask2(tagName, tagMessage), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.deleteLocalBranch = function(branchName, forceDelete, then) { + return this._runTask(deleteBranchTask2(branchName, typeof forceDelete === "boolean" ? forceDelete : false), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.deleteLocalBranches = function(branchNames, forceDelete, then) { + return this._runTask(deleteBranchesTask2(branchNames, typeof forceDelete === "boolean" ? forceDelete : false), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.branch = function(options, then) { + return this._runTask(branchTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.branchLocal = function(then) { + return this._runTask(branchLocalTask2(), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.raw = function(commands2) { + const createRestCommands = !Array.isArray(commands2); + const command = [].slice.call(createRestCommands ? arguments : commands2, 0); + for (let i = 0; i < command.length && createRestCommands; i++) { + if (!filterPrimitives2(command[i])) { + command.splice(i, command.length - i); + break; + } + } + command.push(...getTrailingOptions2(arguments, 0, true)); + var next = trailingFunctionArgument2(arguments); + if (!command.length) { + return this._runTask(configurationErrorTask2("Raw: must supply one or more command to execute"), next); + } + return this._runTask(straightThroughStringTask2(command, this._trimmed), next); + }; + Git2.prototype.submoduleAdd = function(repo, path2, then) { + return this._runTask(addSubModuleTask2(repo, path2), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.submoduleUpdate = function(args, then) { + return this._runTask(updateSubModuleTask2(getTrailingOptions2(arguments, true)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.submoduleInit = function(args, then) { + return this._runTask(initSubModuleTask2(getTrailingOptions2(arguments, true)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.subModule = function(options, then) { + return this._runTask(subModuleTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.listRemote = function() { + return this._runTask(listRemotesTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.addRemote = function(remoteName, remoteRepo, then) { + return this._runTask(addRemoteTask2(remoteName, remoteRepo, getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.removeRemote = function(remoteName, then) { + return this._runTask(removeRemoteTask2(remoteName), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.getRemotes = function(verbose, then) { + return this._runTask(getRemotesTask2(verbose === true), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.remote = function(options, then) { + return this._runTask(remoteTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.tag = function(options, then) { + const command = getTrailingOptions2(arguments); + if (command[0] !== "tag") { + command.unshift("tag"); + } + return this._runTask(straightThroughStringTask2(command), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.updateServerInfo = function(then) { + return this._runTask(straightThroughStringTask2(["update-server-info"]), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.pushTags = function(remote, then) { + const task = pushTagsTask2({ remote: filterType2(remote, filterString2) }, getTrailingOptions2(arguments)); + return this._runTask(task, trailingFunctionArgument2(arguments)); + }; + Git2.prototype.rm = function(files) { + return this._runTask(straightThroughStringTask2(["rm", "-f", ...asArray2(files)]), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.rmKeepLocal = function(files) { + return this._runTask(straightThroughStringTask2(["rm", "--cached", ...asArray2(files)]), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.catFile = function(options, then) { + return this._catFile("utf-8", arguments); + }; + Git2.prototype.binaryCatFile = function() { + return this._catFile("buffer", arguments); + }; + Git2.prototype._catFile = function(format, args) { + var handler = trailingFunctionArgument2(args); + var command = ["cat-file"]; + var options = args[0]; + if (typeof options === "string") { + return this._runTask(configurationErrorTask2("Git.catFile: options must be supplied as an array of strings"), handler); + } + if (Array.isArray(options)) { + command.push.apply(command, options); + } + const task = format === "buffer" ? straightThroughBufferTask2(command) : straightThroughStringTask2(command); + return this._runTask(task, handler); + }; + Git2.prototype.diff = function(options, then) { + const task = filterString2(options) ? configurationErrorTask2("git.diff: supplying options as a single string is no longer supported, switch to an array of strings") : straightThroughStringTask2(["diff", ...getTrailingOptions2(arguments)]); + return this._runTask(task, trailingFunctionArgument2(arguments)); + }; + Git2.prototype.diffSummary = function() { + return this._runTask(diffSummaryTask2(getTrailingOptions2(arguments, 1)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.applyPatch = function(patches) { + const task = !filterStringOrStringArray2(patches) ? configurationErrorTask2(`git.applyPatch requires one or more string patches as the first argument`) : applyPatchTask2(asArray2(patches), getTrailingOptions2([].slice.call(arguments, 1))); + return this._runTask(task, trailingFunctionArgument2(arguments)); + }; + Git2.prototype.revparse = function() { + const commands2 = ["rev-parse", ...getTrailingOptions2(arguments, true)]; + return this._runTask(straightThroughStringTask2(commands2, true), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.show = function(options, then) { + return this._runTask(straightThroughStringTask2(["show", ...getTrailingOptions2(arguments, 1)]), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.clean = function(mode, options, then) { + const usingCleanOptionsArray = isCleanOptionsArray2(mode); + const cleanMode = usingCleanOptionsArray && mode.join("") || filterType2(mode, filterString2) || ""; + const customArgs = getTrailingOptions2([].slice.call(arguments, usingCleanOptionsArray ? 1 : 0)); + return this._runTask(cleanWithOptionsTask2(cleanMode, customArgs), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.exec = function(then) { + const task = { + commands: [], + format: "utf-8", + parser() { + if (typeof then === "function") { + then(); + } + } + }; + return this._runTask(task); + }; + Git2.prototype.clearQueue = function() { + return this; + }; + Git2.prototype.checkIgnore = function(pathnames, then) { + return this._runTask(checkIgnoreTask2(asArray2(filterType2(pathnames, filterStringOrStringArray2, []))), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.checkIsRepo = function(checkType, then) { + return this._runTask(checkIsRepoTask2(filterType2(checkType, filterString2)), trailingFunctionArgument2(arguments)); + }; + module2.exports = Git2; + } +}); +init_git_error(); +var GitConstructError = class extends GitError { + constructor(config, message) { + super(void 0, message); + this.config = config; + } +}; +init_git_error(); +init_git_error(); +var GitPluginError = class extends GitError { + constructor(task, plugin, message) { + super(task, message); + this.task = task; + this.plugin = plugin; + Object.setPrototypeOf(this, new.target.prototype); + } +}; +init_git_response_error(); +init_task_configuration_error(); +init_check_is_repo(); +init_clean(); +init_config(); +init_grep(); +init_reset(); +function abortPlugin(signal) { + if (!signal) { + return; + } + const onSpawnAfter = { + type: "spawn.after", + action(_data, context) { + function kill() { + context.kill(new GitPluginError(void 0, "abort", "Abort signal received")); + } + signal.addEventListener("abort", kill); + context.spawned.on("close", () => signal.removeEventListener("abort", kill)); + } + }; + const onSpawnBefore = { + type: "spawn.before", + action(_data, context) { + if (signal.aborted) { + context.kill(new GitPluginError(void 0, "abort", "Abort already signaled")); + } + } + }; + return [onSpawnBefore, onSpawnAfter]; +} +function isConfigSwitch(arg) { + return typeof arg === "string" && arg.trim().toLowerCase() === "-c"; +} +function preventProtocolOverride(arg, next) { + if (!isConfigSwitch(arg)) { + return; + } + if (!/^\s*protocol(.[a-z]+)?.allow/.test(next)) { + return; + } + throw new GitPluginError(void 0, "unsafe", "Configuring protocol.allow is not permitted without enabling allowUnsafeExtProtocol"); +} +function preventUploadPack(arg, method2) { + if (/^\s*--(upload|receive)-pack/.test(arg)) { + throw new GitPluginError(void 0, "unsafe", `Use of --upload-pack or --receive-pack is not permitted without enabling allowUnsafePack`); + } + if (method2 === "clone" && /^\s*-u\b/.test(arg)) { + throw new GitPluginError(void 0, "unsafe", `Use of clone with option -u is not permitted without enabling allowUnsafePack`); + } + if (method2 === "push" && /^\s*--exec\b/.test(arg)) { + throw new GitPluginError(void 0, "unsafe", `Use of push with option --exec is not permitted without enabling allowUnsafePack`); + } +} +function blockUnsafeOperationsPlugin({ + allowUnsafeProtocolOverride = false, + allowUnsafePack = false +} = {}) { + return { + type: "spawn.args", + action(args, context) { + args.forEach((current, index2) => { + const next = index2 < args.length ? args[index2 + 1] : ""; + allowUnsafeProtocolOverride || preventProtocolOverride(current, next); + allowUnsafePack || preventUploadPack(current, context.method); + }); + return args; + } + }; +} +init_utils(); +function commandConfigPrefixingPlugin(configuration) { + const prefix = prefixedArray(configuration, "-c"); + return { + type: "spawn.args", + action(data) { + return [...prefix, ...data]; + } + }; +} +init_utils(); +var never = (0, import_promise_deferred2.deferred)().promise; +function completionDetectionPlugin({ + onClose = true, + onExit = 50 +} = {}) { + function createEvents() { + let exitCode = -1; + const events = { + close: (0, import_promise_deferred2.deferred)(), + closeTimeout: (0, import_promise_deferred2.deferred)(), + exit: (0, import_promise_deferred2.deferred)(), + exitTimeout: (0, import_promise_deferred2.deferred)() + }; + const result = Promise.race([ + onClose === false ? never : events.closeTimeout.promise, + onExit === false ? never : events.exitTimeout.promise + ]); + configureTimeout(onClose, events.close, events.closeTimeout); + configureTimeout(onExit, events.exit, events.exitTimeout); + return { + close(code) { + exitCode = code; + events.close.done(); + }, + exit(code) { + exitCode = code; + events.exit.done(); + }, + get exitCode() { + return exitCode; + }, + result + }; + } + function configureTimeout(flag, event, timeout) { + if (flag === false) { + return; + } + (flag === true ? event.promise : event.promise.then(() => delay(flag))).then(timeout.done); + } + return { + type: "spawn.after", + action(_0, _1) { + return __async(this, arguments, function* (_data, { spawned, close }) { + var _a2, _b; + const events = createEvents(); + let deferClose = true; + let quickClose = () => void (deferClose = false); + (_a2 = spawned.stdout) == null ? void 0 : _a2.on("data", quickClose); + (_b = spawned.stderr) == null ? void 0 : _b.on("data", quickClose); + spawned.on("error", quickClose); + spawned.on("close", (code) => events.close(code)); + spawned.on("exit", (code) => events.exit(code)); + try { + yield events.result; + if (deferClose) { + yield delay(50); + } + close(events.exitCode); + } catch (err) { + close(events.exitCode, err); + } + }); + } + }; +} +init_git_error(); +function isTaskError(result) { + return !!(result.exitCode && result.stdErr.length); +} +function getErrorMessage(result) { + return Buffer.concat([...result.stdOut, ...result.stdErr]); +} +function errorDetectionHandler(overwrite = false, isError = isTaskError, errorMessage = getErrorMessage) { + return (error, result) => { + if (!overwrite && error || !isError(result)) { + return error; + } + return errorMessage(result); + }; +} +function errorDetectionPlugin(config) { + return { + type: "task.error", + action(data, context) { + const error = config(data.error, { + stdErr: context.stdErr, + stdOut: context.stdOut, + exitCode: context.exitCode + }); + if (Buffer.isBuffer(error)) { + return { error: new GitError(void 0, error.toString("utf-8")) }; + } + return { + error + }; + } + }; +} +init_utils(); +var PluginStore = class { + constructor() { + this.plugins = /* @__PURE__ */ new Set(); + } + add(plugin) { + const plugins = []; + asArray(plugin).forEach((plugin2) => plugin2 && this.plugins.add(append(plugins, plugin2))); + return () => { + plugins.forEach((plugin2) => this.plugins.delete(plugin2)); + }; + } + exec(type, data, context) { + let output = data; + const contextual = Object.freeze(Object.create(context)); + for (const plugin of this.plugins) { + if (plugin.type === type) { + output = plugin.action(output, contextual); + } + } + return output; + } +}; +init_utils(); +function progressMonitorPlugin(progress) { + const progressCommand = "--progress"; + const progressMethods = ["checkout", "clone", "fetch", "pull", "push"]; + const onProgress = { + type: "spawn.after", + action(_data, context) { + var _a2; + if (!context.commands.includes(progressCommand)) { + return; + } + (_a2 = context.spawned.stderr) == null ? void 0 : _a2.on("data", (chunk) => { + const message = /^([\s\S]+?):\s*(\d+)% \((\d+)\/(\d+)\)/.exec(chunk.toString("utf8")); + if (!message) { + return; + } + progress({ + method: context.method, + stage: progressEventStage(message[1]), + progress: asNumber(message[2]), + processed: asNumber(message[3]), + total: asNumber(message[4]) + }); + }); + } + }; + const onArgs = { + type: "spawn.args", + action(args, context) { + if (!progressMethods.includes(context.method)) { + return args; + } + return including(args, progressCommand); + } + }; + return [onArgs, onProgress]; +} +function progressEventStage(input) { + return String(input.toLowerCase().split(" ", 1)) || "unknown"; +} +init_utils(); +function spawnOptionsPlugin(spawnOptions) { + const options = pick(spawnOptions, ["uid", "gid"]); + return { + type: "spawn.options", + action(data) { + return __spreadValues(__spreadValues({}, options), data); + } + }; +} +function timeoutPlugin({ + block, + stdErr = true, + stdOut = true +}) { + if (block > 0) { + return { + type: "spawn.after", + action(_data, context) { + var _a2, _b; + let timeout; + function wait3() { + timeout && clearTimeout(timeout); + timeout = setTimeout(kill, block); + } + function stop() { + var _a3, _b2; + (_a3 = context.spawned.stdout) == null ? void 0 : _a3.off("data", wait3); + (_b2 = context.spawned.stderr) == null ? void 0 : _b2.off("data", wait3); + context.spawned.off("exit", stop); + context.spawned.off("close", stop); + timeout && clearTimeout(timeout); + } + function kill() { + stop(); + context.kill(new GitPluginError(void 0, "timeout", `block timeout reached`)); + } + stdOut && ((_a2 = context.spawned.stdout) == null ? void 0 : _a2.on("data", wait3)); + stdErr && ((_b = context.spawned.stderr) == null ? void 0 : _b.on("data", wait3)); + context.spawned.on("exit", stop); + context.spawned.on("close", stop); + wait3(); + } + }; + } +} +init_utils(); +var Git = require_git(); +function gitInstanceFactory(baseDir, options) { + const plugins = new PluginStore(); + const config = createInstanceConfig(baseDir && (typeof baseDir === "string" ? { baseDir } : baseDir) || {}, options); + if (!folderExists(config.baseDir)) { + throw new GitConstructError(config, `Cannot use simple-git on a directory that does not exist`); + } + if (Array.isArray(config.config)) { + plugins.add(commandConfigPrefixingPlugin(config.config)); + } + plugins.add(blockUnsafeOperationsPlugin(config.unsafe)); + plugins.add(completionDetectionPlugin(config.completion)); + config.abort && plugins.add(abortPlugin(config.abort)); + config.progress && plugins.add(progressMonitorPlugin(config.progress)); + config.timeout && plugins.add(timeoutPlugin(config.timeout)); + config.spawnOptions && plugins.add(spawnOptionsPlugin(config.spawnOptions)); + plugins.add(errorDetectionPlugin(errorDetectionHandler(true))); + config.errors && plugins.add(errorDetectionPlugin(config.errors)); + return new Git(config, plugins); +} +init_git_response_error(); +var esm_default = gitInstanceFactory; + +// src/constants.ts +init_polyfill_buffer(); +var import_obsidian2 = require("obsidian"); +var DATE_FORMAT = "YYYY-MM-DD"; +var DATE_TIME_FORMAT_MINUTES = `${DATE_FORMAT} HH:mm`; +var DATE_TIME_FORMAT_SECONDS = `${DATE_FORMAT} HH:mm:ss`; +var GIT_LINE_AUTHORING_MOVEMENT_DETECTION_MINIMAL_LENGTH = 40; +var DEFAULT_SETTINGS = { + commitMessage: "vault backup: {{date}}", + commitDateFormat: DATE_TIME_FORMAT_SECONDS, + autoSaveInterval: 0, + autoPushInterval: 0, + autoPullInterval: 0, + autoPullOnBoot: false, + disablePush: false, + pullBeforePush: true, + disablePopups: false, + listChangedFilesInMessageBody: false, + showStatusBar: true, + updateSubmodules: false, + syncMethod: "merge", + customMessageOnAutoBackup: false, + autoBackupAfterFileChange: false, + treeStructure: false, + refreshSourceControl: import_obsidian2.Platform.isDesktopApp, + basePath: "", + differentIntervalCommitAndPush: false, + changedFilesInStatusBar: false, + showedMobileNotice: false, + refreshSourceControlTimer: 7e3, + showBranchStatusBar: true, + setLastSaveToLastCommit: false, + submoduleRecurseCheckout: false, + gitDir: "", + showFileMenu: true, + lineAuthor: { + show: false, + followMovement: "inactive", + authorDisplay: "initials", + showCommitHash: false, + dateTimeFormatOptions: "date", + dateTimeFormatCustomString: DATE_TIME_FORMAT_MINUTES, + dateTimeTimezone: "viewer-local", + coloringMaxAge: "1y", + // colors were picked via: + // https://color.adobe.com/de/create/color-accessibility + colorNew: { r: 255, g: 150, b: 150 }, + colorOld: { r: 120, g: 160, b: 255 }, + textColorCss: "var(--text-muted)", + // more pronounced than line numbers, but less than the content text + ignoreWhitespace: false, + gutterSpacingFallbackLength: 5 + } +}; +var SOURCE_CONTROL_VIEW_CONFIG = { + type: "git-view", + name: "Source Control", + icon: "git-pull-request" +}; +var HISTORY_VIEW_CONFIG = { + type: "git-history-view", + name: "History", + icon: "history" +}; +var DIFF_VIEW_CONFIG = { + type: "diff-view", + name: "Diff View", + icon: "git-pull-request" +}; + +// src/types.ts +init_polyfill_buffer(); +function mergeSettingsByPriority(low, high) { + const lineAuthor = Object.assign({}, low.lineAuthor, high.lineAuthor); + return Object.assign({}, low, high, { lineAuthor }); +} + +// src/utils.ts +init_polyfill_buffer(); +var cssColorConverter = __toESM(require_lib3()); +var import_deep_equal = __toESM(require_deep_equal()); +var import_obsidian3 = require("obsidian"); +var worthWalking2 = (filepath, root2) => { + if (filepath === "." || root2 == null || root2.length === 0 || root2 === ".") { + return true; + } + if (root2.length >= filepath.length) { + return root2.startsWith(filepath); + } else { + return filepath.startsWith(root2); + } +}; +function getNewLeaf(event) { + let leaf; + if (event) { + if (event.button === 0 || event.button === 1) { + const type = import_obsidian3.Keymap.isModEvent(event); + leaf = app.workspace.getLeaf(type); + } + } else { + leaf = app.workspace.getLeaf(false); + } + return leaf; +} +function impossibleBranch(x) { + throw new Error("Impossible branch: " + x); +} +function rgbToString(rgb) { + return `rgb(${rgb.r},${rgb.g},${rgb.b})`; +} +function convertToRgb(str) { + var _a2; + const color = (_a2 = cssColorConverter.fromString(str)) == null ? void 0 : _a2.toRgbaArray(); + if (color === void 0) { + return void 0; + } + const [r, g, b] = color; + return { r, g, b }; +} +function momentToEpochSeconds(instant) { + return instant.diff(import_obsidian3.moment.unix(0), "seconds"); +} +function median(array) { + if (array.length === 0) + return void 0; + return array.slice().sort()[Math.floor(array.length / 2)]; +} +function strictDeepEqual(a, b) { + return (0, import_deep_equal.default)(a, b, { strict: true }); +} +function resizeToLength(original, desiredLength, fillChar) { + if (original.length <= desiredLength) { + const prefix = new Array(desiredLength - original.length).fill(fillChar).join(""); + return prefix + original; + } else { + return original.substring(original.length - desiredLength); + } +} +function prefixOfLengthAsWhitespace(toBeRenderedText, whitespacePrefixLength) { + if (whitespacePrefixLength <= 0) + return toBeRenderedText; + const whitespacePrefix = new Array(whitespacePrefixLength).fill(" ").join(""); + const originalSuffix = toBeRenderedText.substring( + whitespacePrefixLength, + toBeRenderedText.length + ); + return whitespacePrefix + originalSuffix; +} +function between(l, x, r) { + return l <= x && x <= r; +} +function splitRemoteBranch(remoteBranch) { + const [remote, ...branch2] = remoteBranch.split("/"); + return [remote, branch2.length === 0 ? void 0 : branch2.join("/")]; +} +function getDisplayPath(path2) { + if (path2.endsWith("/")) + return path2; + return path2.split("/").last().replace(".md", ""); +} + +// src/gitManager/gitManager.ts +init_polyfill_buffer(); +var GitManager = class { + constructor(plugin) { + this.plugin = plugin; + this.app = plugin.app; + } + getVaultPath(path2) { + if (this.plugin.settings.basePath) { + return this.plugin.settings.basePath + "/" + path2; + } else { + return path2; + } + } + asRepositoryRelativePath(path2, relativeToVault) { + return relativeToVault && this.plugin.settings.basePath.length > 0 ? path2.substring(this.plugin.settings.basePath.length + 1) : path2; + } + _getTreeStructure(children2, beginLength = 0) { + const list = []; + children2 = [...children2]; + while (children2.length > 0) { + const first2 = children2.first(); + const restPath = first2.path.substring(beginLength); + if (restPath.contains("/")) { + const title = restPath.substring(0, restPath.indexOf("/")); + const childrenWithSameTitle = children2.filter((item) => { + return item.path.substring(beginLength).startsWith(title + "/"); + }); + childrenWithSameTitle.forEach((item) => children2.remove(item)); + const path2 = first2.path.substring( + 0, + restPath.indexOf("/") + beginLength + ); + list.push({ + title, + path: path2, + vaultPath: this.getVaultPath(path2), + children: this._getTreeStructure( + childrenWithSameTitle, + (beginLength > 0 ? beginLength + title.length : title.length) + 1 + ) + }); + } else { + list.push({ + title: restPath, + data: first2, + path: first2.path, + vaultPath: this.getVaultPath(first2.path) + }); + children2.remove(first2); + } + } + return list; + } + /* + * Sorts the children and simplifies the title + * If a node only contains another subdirectory, that subdirectory is moved up one level and integrated into the parent node + */ + simplify(tree) { + var _a2, _b, _c, _d; + for (const node of tree) { + while (true) { + const singleChild = ((_a2 = node.children) == null ? void 0 : _a2.length) == 1; + const singleChildIsDir = ((_c = (_b = node.children) == null ? void 0 : _b.first()) == null ? void 0 : _c.data) == void 0; + if (!(node.children != void 0 && singleChild && singleChildIsDir)) + break; + const child = node.children.first(); + node.title += "/" + child.title; + node.data = child.data; + node.path = child.path; + node.vaultPath = child.vaultPath; + node.children = child.children; + } + if (node.children != void 0) { + this.simplify(node.children); + } + (_d = node.children) == null ? void 0 : _d.sort((a, b) => { + const dirCompare = (b.data == void 0 ? 1 : 0) - (a.data == void 0 ? 1 : 0); + if (dirCompare != 0) { + return dirCompare; + } else { + return a.title.localeCompare(b.title); + } + }); + } + return tree.sort((a, b) => { + const dirCompare = (b.data == void 0 ? 1 : 0) - (a.data == void 0 ? 1 : 0); + if (dirCompare != 0) { + return dirCompare; + } else { + return a.title.localeCompare(b.title); + } + }); + } + getTreeStructure(children2) { + const tree = this._getTreeStructure(children2); + const res = this.simplify(tree); + return res; + } + async formatCommitMessage(template) { + let status2; + if (template.includes("{{numFiles}}")) { + status2 = await this.status(); + const numFiles = status2.staged.length; + template = template.replace("{{numFiles}}", String(numFiles)); + } + if (template.includes("{{hostname}}")) { + const hostname = this.plugin.localStorage.getHostname() || ""; + template = template.replace("{{hostname}}", hostname); + } + if (template.includes("{{files}}")) { + status2 = status2 != null ? status2 : await this.status(); + const changeset = {}; + status2.staged.forEach((value) => { + if (value.index in changeset) { + changeset[value.index].push(value.path); + } else { + changeset[value.index] = [value.path]; + } + }); + const chunks = []; + for (const [action, files2] of Object.entries(changeset)) { + chunks.push(action + " " + files2.join(" ")); + } + const files = chunks.join(", "); + template = template.replace("{{files}}", files); + } + const moment5 = window.moment; + template = template.replace( + "{{date}}", + moment5().format(this.plugin.settings.commitDateFormat) + ); + if (this.plugin.settings.listChangedFilesInMessageBody) { + template = template + "\n\nAffected files:\n" + (status2 != null ? status2 : await this.status()).staged.map((e) => e.path).join("\n"); + } + return template; + } +}; + +// src/gitManager/simpleGit.ts +var SimpleGit = class extends GitManager { + constructor(plugin) { + super(plugin); + } + async setGitInstance(ignoreError = false) { + if (this.isGitInstalled()) { + const adapter = this.app.vault.adapter; + const path2 = adapter.getBasePath(); + let basePath = path2; + if (this.plugin.settings.basePath) { + const exists2 = await adapter.exists( + (0, import_obsidian4.normalizePath)(this.plugin.settings.basePath) + ); + if (exists2) { + basePath = path2 + import_path.sep + this.plugin.settings.basePath; + } else if (!ignoreError) { + new import_obsidian4.Notice("ObsidianGit: Base path does not exist"); + } + } + this.git = esm_default({ + baseDir: basePath, + binary: this.plugin.localStorage.getGitPath() || void 0, + config: ["core.quotepath=off"] + }); + const pathPaths = this.plugin.localStorage.getPATHPaths(); + const envVars = this.plugin.localStorage.getEnvVars(); + const gitDir = this.plugin.settings.gitDir; + if (pathPaths.length > 0) { + const path3 = process.env["PATH"] + ":" + pathPaths.join(":"); + process.env["PATH"] = path3; + } + if (gitDir) { + process.env["GIT_DIR"] = gitDir; + } + for (const envVar of envVars) { + const [key2, value] = envVar.split("="); + process.env[key2] = value; + } + import_debug2.default.enable("simple-git"); + if (await this.git.checkIsRepo()) { + await this.git.cwd(await this.git.revparse("--show-toplevel")); + } + } + } + async status() { + this.plugin.setState(1 /* status */); + const status2 = await this.git.status((err) => this.onError(err)); + this.plugin.setState(0 /* idle */); + return { + changed: status2.files.filter((e) => e.working_dir !== " ").map((e) => { + const res = this.formatPath(e); + return { + path: res.path, + from: res.from, + working_dir: e.working_dir === "?" ? "U" : e.working_dir, + vault_path: this.getVaultPath(res.path) + }; + }), + staged: status2.files.filter((e) => e.index !== " " && e.index != "?").map((e) => { + const res = this.formatPath(e, e.index === "R"); + return { + path: res.path, + from: res.from, + index: e.index, + vault_path: this.getVaultPath(res.path) + }; + }), + conflicted: status2.conflicted.map( + (path2) => this.formatPath({ path: path2 }).path + ) + }; + } + async submoduleAwareHeadRevisonInContainingDirectory(filepath) { + const repoPath = this.asRepositoryRelativePath(filepath, true); + const containingDirectory = path.dirname(repoPath); + const args = ["-C", containingDirectory, "rev-parse", "HEAD"]; + const result = this.git.raw(args); + result.catch( + (err) => console.warn("obsidian-git: rev-parse error:", err) + ); + return result; + } + async getSubmodulePaths() { + return new Promise(async (resolve) => { + this.git.outputHandler(async (cmd, stdout, stderr, args) => { + if (!(args.contains("submodule") && args.contains("foreach"))) { + return; + } + let body = ""; + const root2 = this.app.vault.adapter.getBasePath() + (this.plugin.settings.basePath ? "/" + this.plugin.settings.basePath : ""); + stdout.on("data", (chunk) => { + body += chunk.toString("utf8"); + }); + stdout.on("end", async () => { + const submods = body.split("\n"); + const strippedSubmods = submods.map((i) => { + const submod = i.match(/'([^']*)'/); + if (submod != void 0) { + return root2 + "/" + submod[1] + import_path.sep; + } + }).filter((i) => !!i); + strippedSubmods.reverse(); + resolve(strippedSubmods); + }); + }); + await this.git.subModule(["foreach", "--recursive", ""]); + this.git.outputHandler(() => { + }); + }); + } + //Remove wrong `"` like "My file.md" + formatPath(path2, renamed = false) { + function format(path3) { + if (path3 == void 0) + return void 0; + if (path3.startsWith('"') && path3.endsWith('"')) { + return path3.substring(1, path3.length - 1); + } else { + return path3; + } + } + if (renamed) { + return { + from: format(path2.from), + path: format(path2.path) + }; + } else { + return { + path: format(path2.path) + }; + } + } + async blame(path2, trackMovement, ignoreWhitespace) { + path2 = this.asRepositoryRelativePath(path2, true); + if (!await this.isTracked(path2)) + return "untracked"; + const inSubmodule = await this.getSubmoduleOfFile(path2); + const args = inSubmodule ? ["-C", inSubmodule.submodule] : []; + const relativePath = inSubmodule ? inSubmodule.relativeFilepath : path2; + args.push("blame", "--porcelain"); + if (ignoreWhitespace) + args.push("-w"); + const trackCArg = `-C${GIT_LINE_AUTHORING_MOVEMENT_DETECTION_MINIMAL_LENGTH}`; + switch (trackMovement) { + case "inactive": + break; + case "same-commit": + args.push("-C", trackCArg); + break; + case "all-commits": + args.push("-C", "-C", trackCArg); + break; + default: + impossibleBranch(trackMovement); + } + args.push("--", relativePath); + const rawBlame = await this.git.raw( + args, + (err) => err && console.warn("git-blame", err) + ); + return parseBlame(rawBlame); + } + async isTracked(path2) { + const inSubmodule = await this.getSubmoduleOfFile(path2); + const args = inSubmodule ? ["-C", inSubmodule.submodule] : []; + const relativePath = inSubmodule ? inSubmodule.relativeFilepath : path2; + args.push("ls-files", "--", relativePath); + return this.git.raw(args, (err) => err && console.warn("ls-files", err)).then((x) => x.trim() !== ""); + } + async commitAll({ message }) { + if (this.plugin.settings.updateSubmodules) { + this.plugin.setState(4 /* commit */); + const submodulePaths = await this.getSubmodulePaths(); + for (const item of submodulePaths) { + await this.git.cwd({ path: item, root: false }).add("-A", (err) => this.onError(err)); + await this.git.cwd({ path: item, root: false }).commit( + await this.formatCommitMessage(message), + (err) => this.onError(err) + ); + } + } + this.plugin.setState(3 /* add */); + await this.git.add("-A", (err) => this.onError(err)); + this.plugin.setState(4 /* commit */); + const res = await this.git.commit( + await this.formatCommitMessage(message), + (err) => this.onError(err) + ); + dispatchEvent(new CustomEvent("git-head-update")); + return res.summary.changes; + } + async commit(message) { + this.plugin.setState(4 /* commit */); + const res = (await this.git.commit( + await this.formatCommitMessage(message), + (err) => this.onError(err) + )).summary.changes; + dispatchEvent(new CustomEvent("git-head-update")); + this.plugin.setState(0 /* idle */); + return res; + } + async stage(path2, relativeToVault) { + this.plugin.setState(3 /* add */); + path2 = this.asRepositoryRelativePath(path2, relativeToVault); + await this.git.add(["--", path2], (err) => this.onError(err)); + this.plugin.setState(0 /* idle */); + } + async stageAll({ dir }) { + this.plugin.setState(3 /* add */); + await this.git.add(dir != null ? dir : "-A", (err) => this.onError(err)); + this.plugin.setState(0 /* idle */); + } + async unstageAll({ dir }) { + this.plugin.setState(3 /* add */); + await this.git.reset( + dir != void 0 ? ["--", dir] : [], + (err) => this.onError(err) + ); + this.plugin.setState(0 /* idle */); + } + async unstage(path2, relativeToVault) { + this.plugin.setState(3 /* add */); + path2 = this.asRepositoryRelativePath(path2, relativeToVault); + await this.git.reset(["--", path2], (err) => this.onError(err)); + this.plugin.setState(0 /* idle */); + } + async discard(filepath) { + this.plugin.setState(3 /* add */); + await this.git.checkout(["--", filepath], (err) => this.onError(err)); + this.plugin.setState(0 /* idle */); + } + async hashObject(filepath) { + filepath = this.asRepositoryRelativePath(filepath, true); + const inSubmodule = await this.getSubmoduleOfFile(filepath); + const args = inSubmodule ? ["-C", inSubmodule.submodule] : []; + const relativeFilepath = inSubmodule ? inSubmodule.relativeFilepath : filepath; + args.push("hash-object", "--", relativeFilepath); + const revision = this.git.raw(args); + revision.catch( + (err) => err && console.warn("obsidian-git. hash-object failed:", err == null ? void 0 : err.message) + ); + return revision; + } + async discardAll({ dir }) { + return this.discard(dir != null ? dir : "."); + } + async pull() { + this.plugin.setState(2 /* pull */); + if (this.plugin.settings.updateSubmodules) + await this.git.subModule( + ["update", "--remote", "--merge", "--recursive"], + (err) => this.onError(err) + ); + const branchInfo = await this.branchInfo(); + const localCommit = await this.git.revparse( + [branchInfo.current], + (err) => this.onError(err) + ); + await this.git.fetch((err) => this.onError(err)); + const upstreamCommit = await this.git.revparse( + [branchInfo.tracking], + (err) => this.onError(err) + ); + if (localCommit !== upstreamCommit) { + if (this.plugin.settings.syncMethod === "merge" || this.plugin.settings.syncMethod === "rebase") { + try { + switch (this.plugin.settings.syncMethod) { + case "merge": + await this.git.merge([branchInfo.tracking]); + break; + case "rebase": + await this.git.rebase([branchInfo.tracking]); + } + } catch (err) { + this.plugin.displayError( + `Pull failed (${this.plugin.settings.syncMethod}): ${err.message}` + ); + return; + } + } else if (this.plugin.settings.syncMethod === "reset") { + try { + await this.git.raw( + [ + "update-ref", + `refs/heads/${branchInfo.current}`, + upstreamCommit + ], + (err) => this.onError(err) + ); + await this.unstageAll({}); + } catch (err) { + this.plugin.displayError( + `Sync failed (${this.plugin.settings.syncMethod}): ${err.message}` + ); + } + } + dispatchEvent(new CustomEvent("git-head-update")); + const afterMergeCommit = await this.git.revparse( + [branchInfo.current], + (err) => this.onError(err) + ); + const filesChanged = await this.git.diff([ + `${localCommit}..${afterMergeCommit}`, + "--name-only" + ]); + return filesChanged.split(/\r\n|\r|\n/).filter((value) => value.length > 0).map((e) => { + return { + path: e, + working_dir: "P", + vault_path: this.getVaultPath(e) + }; + }); + } else { + return []; + } + } + async push() { + this.plugin.setState(1 /* status */); + const status2 = await this.git.status(); + const trackingBranch = status2.tracking; + const currentBranch2 = status2.current; + const remoteChangedFiles = (await this.git.diffSummary( + [currentBranch2, trackingBranch, "--"], + (err) => this.onError(err) + )).changed; + this.plugin.setState(5 /* push */); + if (this.plugin.settings.updateSubmodules) { + await this.git.env({ ...process.env, OBSIDIAN_GIT: 1 }).subModule( + [ + "foreach", + "--recursive", + `tracking=$(git for-each-ref --format='%(upstream:short)' "$(git symbolic-ref -q HEAD)"); echo $tracking; if [ ! -z "$(git diff --shortstat $tracking)" ]; then git push; fi` + ], + (err) => this.onError(err) + ); + } + await this.git.env({ ...process.env, OBSIDIAN_GIT: 1 }).push((err) => this.onError(err)); + return remoteChangedFiles; + } + async getUnpushedCommits() { + const status2 = await this.git.status(); + const trackingBranch = status2.tracking; + const currentBranch2 = status2.current; + if (trackingBranch == null || currentBranch2 == null) { + return 0; + } + const remoteChangedFiles = (await this.git.diffSummary( + [currentBranch2, trackingBranch, "--"], + (err) => this.onError(err) + )).changed; + return remoteChangedFiles; + } + async canPush() { + if (this.plugin.settings.updateSubmodules === true) { + return true; + } + const status2 = await this.git.status((err) => this.onError(err)); + const trackingBranch = status2.tracking; + const currentBranch2 = status2.current; + const remoteChangedFiles = (await this.git.diffSummary([currentBranch2, trackingBranch, "--"])).changed; + return remoteChangedFiles !== 0; + } + async checkRequirements() { + if (!this.isGitInstalled()) { + return "missing-git"; + } + if (!await this.git.checkIsRepo()) { + return "missing-repo"; + } + return "valid"; + } + async branchInfo() { + const status2 = await this.git.status((err) => this.onError(err)); + const branches = await this.git.branch( + ["--no-color"], + (err) => this.onError(err) + ); + return { + current: status2.current || void 0, + tracking: status2.tracking || void 0, + branches: branches.all + }; + } + async getRemoteUrl(remote) { + return await this.git.remote( + ["get-url", remote], + (err, url) => this.onError(err) + ) || void 0; + } + // https://github.com/kometenstaub/obsidian-version-history-diff/issues/3 + async log(file, relativeToVault = true, limit) { + let path2; + if (file) { + path2 = this.asRepositoryRelativePath(file, relativeToVault); + } + const res = await this.git.log( + { + file: path2, + maxCount: limit, + "-m": null, + "--name-status": null + }, + (err) => this.onError(err) + ); + return res.all.map((e) => { + var _a2, _b, _c, _d; + return { + ...e, + refs: e.refs.split(", "), + diff: { + ...e.diff, + files: (_b = (_a2 = e.diff) == null ? void 0 : _a2.files.map((f) => ({ + ...f, + status: f.status, + path: f.file, + hash: e.hash, + vault_path: this.getVaultPath(f.file) + }))) != null ? _b : [] + }, + fileName: (_d = (_c = e.diff) == null ? void 0 : _c.files.first()) == null ? void 0 : _d.file + }; + }); + } + async show(commitHash, file, relativeToVault = true) { + const path2 = this.asRepositoryRelativePath(file, relativeToVault); + return this.git.show( + [commitHash + ":" + path2], + (err) => this.onError(err) + ); + } + async checkout(branch2, remote) { + if (remote) { + branch2 = `${remote}/${branch2}`; + } + await this.git.checkout(branch2, (err) => this.onError(err)); + if (this.plugin.settings.submoduleRecurseCheckout) { + const submodulePaths = await this.getSubmodulePaths(); + for (const submodulePath of submodulePaths) { + const branchSummary = await this.git.cwd({ path: submodulePath, root: false }).branch(); + if (Object.keys(branchSummary.branches).includes(branch2)) { + await this.git.cwd({ path: submodulePath, root: false }).checkout(branch2, (err) => this.onError(err)); + } + } + } + } + async createBranch(branch2) { + await this.git.checkout(["-b", branch2], (err) => this.onError(err)); + } + async deleteBranch(branch2, force) { + await this.git.branch( + [force ? "-D" : "-d", branch2], + (err) => this.onError(err) + ); + } + async branchIsMerged(branch2) { + const notMergedBranches = await this.git.branch( + ["--no-merged"], + (err) => this.onError(err) + ); + return !notMergedBranches.all.contains(branch2); + } + async init() { + await this.git.init(false, (err) => this.onError(err)); + } + async clone(url, dir, depth) { + await this.git.clone( + url, + path.join( + this.app.vault.adapter.getBasePath(), + dir + ), + depth ? ["--depth", `${depth}`] : [], + (err) => this.onError(err) + ); + } + async setConfig(path2, value) { + if (value == void 0) { + await this.git.raw(["config", "--local", "--unset", path2]); + } else { + await this.git.addConfig(path2, value, (err) => this.onError(err)); + } + } + async getConfig(path2) { + const config = await this.git.listConfig( + "local", + (err) => this.onError(err) + ); + return config.all[path2]; + } + async fetch(remote) { + await this.git.fetch( + remote != void 0 ? [remote] : [], + (err) => this.onError(err) + ); + } + async setRemote(name, url) { + if ((await this.getRemotes()).includes(name)) + await this.git.remote( + ["set-url", name, url], + (err) => this.onError(err) + ); + else { + await this.git.remote( + ["add", name, url], + (err) => this.onError(err) + ); + } + } + async getRemoteBranches(remote) { + const res = await this.git.branch( + ["-r", "--list", `${remote}*`], + (err) => this.onError(err) + ); + console.log(remote); + console.log(res); + const list = []; + for (const item in res.branches) { + list.push(res.branches[item].name); + } + return list; + } + async getRemotes() { + const res = await this.git.remote([], (err) => this.onError(err)); + if (res) { + return res.trim().split("\n"); + } else { + return []; + } + } + async removeRemote(remoteName) { + await this.git.removeRemote(remoteName); + } + async updateUpstreamBranch(remoteBranch) { + try { + await this.git.branch(["--set-upstream-to", remoteBranch]); + } catch (e) { + console.error(e); + try { + await this.git.branch(["--set-upstream", remoteBranch]); + } catch (e2) { + console.error(e2); + await this.git.push( + // A type error occurs here because the third element could be undefined. + // However, it is unlikely to be undefined due to the `remoteBranch`'s format, and error handling is in place. + // Therefore, we temporarily ignore the error. + // @ts-ignore + ["--set-upstream", ...splitRemoteBranch(remoteBranch)], + (err) => this.onError(err) + ); + } + } + } + updateGitPath(gitPath) { + this.setGitInstance(); + } + updateBasePath(basePath) { + this.setGitInstance(true); + } + async getDiffString(filePath, stagedChanges = false, hash2) { + if (stagedChanges) + return await this.git.diff(["--cached", "--", filePath]); + if (hash2) + return await this.git.show([`${hash2}`, "--", filePath]); + else + return await this.git.diff(["--", filePath]); + } + async diff(file, commit1, commit2) { + return await this.git.diff([`${commit1}..${commit2}`, "--", file]); + } + async getSubmoduleOfFile(repositoryRelativeFile) { + let submoduleRoot = await this.git.raw( + [ + "-C", + path.dirname(repositoryRelativeFile), + "rev-parse", + "--show-toplevel" + ], + (err) => err && console.warn("get-submodule-of-file", err == null ? void 0 : err.message) + ); + submoduleRoot = submoduleRoot.trim(); + const superProject = await this.git.raw( + [ + "-C", + path.dirname(repositoryRelativeFile), + "rev-parse", + "--show-superproject-working-tree" + ], + (err) => err && console.warn("get-submodule-of-file", err == null ? void 0 : err.message) + ); + if (superProject.trim() === "") { + return void 0; + } + const fsAdapter = this.app.vault.adapter; + const absolutePath = fsAdapter.getFullPath( + path.normalize(repositoryRelativeFile) + ); + const newRelativePath = path.relative(submoduleRoot, absolutePath); + return { submodule: submoduleRoot, relativeFilepath: newRelativePath }; + } + async getLastCommitTime() { + const res = await this.git.log({ n: 1 }, (err) => this.onError(err)); + if (res != null && res.latest != null) { + return new Date(res.latest.date); + } + } + isGitInstalled() { + const command = (0, import_child_process2.spawnSync)( + this.plugin.localStorage.getGitPath() || "git", + ["--version"], + { + stdio: "ignore" + } + ); + if (command.error) { + console.error(command.error); + return false; + } + return true; + } + onError(error) { + if (error) { + const networkFailure = error.message.contains("Could not resolve host") || error.message.match( + /ssh: connect to host .*? port .*?: Operation timed out/ + ) || error.message.match( + /ssh: connect to host .*? port .*?: Network is unreachable/ + ); + if (!networkFailure) { + this.plugin.displayError(error.message); + this.plugin.setState(0 /* idle */); + } else if (!this.plugin.offlineMode) { + this.plugin.displayError( + "Git: Going into offline mode. Future network errors will no longer be displayed.", + 2e3 + ); + } + if (networkFailure) { + this.plugin.offlineMode = true; + this.plugin.setState(0 /* idle */); + } + } + } +}; +var zeroCommit = { + hash: "000000", + isZeroCommit: true, + summary: "" +}; +function parseBlame(blameOutputUnnormalized) { + const blameOutput = blameOutputUnnormalized.replace("\r\n", "\n"); + const blameLines = blameOutput.split("\n"); + const result = { + commits: /* @__PURE__ */ new Map(), + hashPerLine: [void 0], + // one-based indices + originalFileLineNrPerLine: [void 0], + finalFileLineNrPerLine: [void 0], + groupSizePerStartingLine: /* @__PURE__ */ new Map() + }; + let line = 1; + for (let bi = 0; bi < blameLines.length; ) { + if (startsWithNonWhitespace(blameLines[bi])) { + const lineInfo = blameLines[bi].split(" "); + const commitHash = parseLineInfoInto(lineInfo, line, result); + bi++; + for (; startsWithNonWhitespace(blameLines[bi]); bi++) { + const spaceSeparatedHeaderValues = blameLines[bi].split(" "); + parseHeaderInto(spaceSeparatedHeaderValues, result, line); + } + finalizeBlameCommitInfo(result.commits.get(commitHash)); + line += 1; + } else if (blameLines[bi] === "" && bi === blameLines.length - 1) { + } else { + throw Error( + `Expected non-whitespace line or EOF, but found: ${blameLines[bi]}` + ); + } + bi++; + } + return result; +} +function parseLineInfoInto(lineInfo, line, result) { + const hash2 = lineInfo[0]; + result.hashPerLine.push(hash2); + result.originalFileLineNrPerLine.push(parseInt(lineInfo[1])); + result.finalFileLineNrPerLine.push(parseInt(lineInfo[2])); + lineInfo.length >= 4 && result.groupSizePerStartingLine.set(line, parseInt(lineInfo[3])); + if (parseInt(lineInfo[2]) !== line) { + throw Error( + `git-blame output is out of order: ${line} vs ${lineInfo[2]}` + ); + } + return hash2; +} +function parseHeaderInto(header, out, line) { + const key2 = header[0]; + const value = header.slice(1).join(" "); + const commitHash = out.hashPerLine[line]; + const commit2 = out.commits.get(commitHash) || { + hash: commitHash, + author: {}, + committer: {}, + previous: {} + }; + switch (key2) { + case "summary": + commit2.summary = value; + break; + case "author": + commit2.author.name = value; + break; + case "author-mail": + commit2.author.email = removeEmailBrackets(value); + break; + case "author-time": + commit2.author.epochSeconds = parseInt(value); + break; + case "author-tz": + commit2.author.tz = value; + break; + case "committer": + commit2.committer.name = value; + break; + case "committer-mail": + commit2.committer.email = removeEmailBrackets(value); + break; + case "committer-time": + commit2.committer.epochSeconds = parseInt(value); + break; + case "committer-tz": + commit2.committer.tz = value; + break; + case "previous": + commit2.previous.commitHash = value; + break; + case "filename": + commit2.previous.filename = value; + break; + } + out.commits.set(commitHash, commit2); +} +function finalizeBlameCommitInfo(commit2) { + if (commit2.summary === void 0) { + throw Error(`Summary not provided for commit: ${commit2.hash}`); + } + if (isUndefinedOrEmptyObject(commit2.author)) { + commit2.author = void 0; + } + if (isUndefinedOrEmptyObject(commit2.committer)) { + commit2.committer = void 0; + } + if (isUndefinedOrEmptyObject(commit2.previous)) { + commit2.previous = void 0; + } + commit2.isZeroCommit = Boolean(commit2.hash.match(/^0*$/)); +} +function isUndefinedOrEmptyObject(obj) { + return !obj || Object.keys(obj).length === 0; +} +function startsWithNonWhitespace(str) { + return str.length > 0 && str[0].trim() === str[0]; +} +function removeEmailBrackets(gitEmail) { + const prefixCleaned = gitEmail.startsWith("<") ? gitEmail.substring(1) : gitEmail; + return prefixCleaned.endsWith(">") ? prefixCleaned.substring(0, prefixCleaned.length - 1) : prefixCleaned; +} + +// src/lineAuthor/lineAuthorProvider.ts +init_polyfill_buffer(); +var import_state4 = require("@codemirror/state"); + +// src/lineAuthor/control.ts +init_polyfill_buffer(); +var import_state2 = require("@codemirror/state"); +var import_obsidian9 = require("obsidian"); + +// src/lineAuthor/eventsPerFilepath.ts +init_polyfill_buffer(); +var SECONDS = 1e3; +var REMOVE_STALES_FREQUENCY = 60 * SECONDS; +var EventsPerFilePath = class { + constructor() { + this.eventsPerFilepath = /* @__PURE__ */ new Map(); + this.startRemoveStalesSubscribersInterval(); + } + /** + * Run the {@link handler} on the subscribers to {@link filepath}. + */ + ifFilepathDefinedTransformSubscribers(filepath, handler) { + if (!filepath) + return; + this.ensureInitialized(filepath); + return handler(this.eventsPerFilepath.get(filepath)); + } + forEachSubscriber(handler) { + this.eventsPerFilepath.forEach((subs) => subs.forEach(handler)); + } + ensureInitialized(filepath) { + if (!this.eventsPerFilepath.get(filepath)) + this.eventsPerFilepath.set(filepath, /* @__PURE__ */ new Set()); + } + startRemoveStalesSubscribersInterval() { + this.removeStalesSubscribersTimer = window.setInterval( + () => this == null ? void 0 : this.forEachSubscriber((las) => las == null ? void 0 : las.removeIfStale()), + REMOVE_STALES_FREQUENCY + ); + } + clear() { + window.clearInterval(this.removeStalesSubscribersTimer); + this.eventsPerFilepath.clear(); + } +}; +var eventsPerFilePathSingleton = new EventsPerFilePath(); + +// src/lineAuthor/model.ts +init_polyfill_buffer(); +var import_state = require("@codemirror/state"); +var import_js_sha256 = __toESM(require_sha256()); + +// src/setting/settings.ts +init_polyfill_buffer(); +var import_obsidian8 = require("obsidian"); + +// src/gitManager/isomorphicGit.ts +init_polyfill_buffer(); + +// node_modules/.pnpm/diff@5.1.0/node_modules/diff/lib/index.mjs +init_polyfill_buffer(); +function Diff() { +} +Diff.prototype = { + diff: function diff(oldString, newString) { + var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}; + var callback = options.callback; + if (typeof options === "function") { + callback = options; + options = {}; + } + this.options = options; + var self2 = this; + function done(value) { + if (callback) { + setTimeout(function() { + callback(void 0, value); + }, 0); + return true; + } else { + return value; + } + } + oldString = this.castInput(oldString); + newString = this.castInput(newString); + oldString = this.removeEmpty(this.tokenize(oldString)); + newString = this.removeEmpty(this.tokenize(newString)); + var newLen = newString.length, oldLen = oldString.length; + var editLength = 1; + var maxEditLength = newLen + oldLen; + if (options.maxEditLength) { + maxEditLength = Math.min(maxEditLength, options.maxEditLength); + } + var bestPath = [{ + newPos: -1, + components: [] + }]; + var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0); + if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) { + return done([{ + value: this.join(newString), + count: newString.length + }]); + } + function execEditLength() { + for (var diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) { + var basePath = void 0; + var addPath = bestPath[diagonalPath - 1], removePath = bestPath[diagonalPath + 1], _oldPos = (removePath ? removePath.newPos : 0) - diagonalPath; + if (addPath) { + bestPath[diagonalPath - 1] = void 0; + } + var canAdd = addPath && addPath.newPos + 1 < newLen, canRemove = removePath && 0 <= _oldPos && _oldPos < oldLen; + if (!canAdd && !canRemove) { + bestPath[diagonalPath] = void 0; + continue; + } + if (!canAdd || canRemove && addPath.newPos < removePath.newPos) { + basePath = clonePath(removePath); + self2.pushComponent(basePath.components, void 0, true); + } else { + basePath = addPath; + basePath.newPos++; + self2.pushComponent(basePath.components, true, void 0); + } + _oldPos = self2.extractCommon(basePath, newString, oldString, diagonalPath); + if (basePath.newPos + 1 >= newLen && _oldPos + 1 >= oldLen) { + return done(buildValues(self2, basePath.components, newString, oldString, self2.useLongestToken)); + } else { + bestPath[diagonalPath] = basePath; + } + } + editLength++; + } + if (callback) { + (function exec() { + setTimeout(function() { + if (editLength > maxEditLength) { + return callback(); + } + if (!execEditLength()) { + exec(); + } + }, 0); + })(); + } else { + while (editLength <= maxEditLength) { + var ret = execEditLength(); + if (ret) { + return ret; + } + } + } + }, + pushComponent: function pushComponent(components, added, removed) { + var last2 = components[components.length - 1]; + if (last2 && last2.added === added && last2.removed === removed) { + components[components.length - 1] = { + count: last2.count + 1, + added, + removed + }; + } else { + components.push({ + count: 1, + added, + removed + }); + } + }, + extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) { + var newLen = newString.length, oldLen = oldString.length, newPos = basePath.newPos, oldPos = newPos - diagonalPath, commonCount = 0; + while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) { + newPos++; + oldPos++; + commonCount++; + } + if (commonCount) { + basePath.components.push({ + count: commonCount + }); + } + basePath.newPos = newPos; + return oldPos; + }, + equals: function equals(left, right) { + if (this.options.comparator) { + return this.options.comparator(left, right); + } else { + return left === right || this.options.ignoreCase && left.toLowerCase() === right.toLowerCase(); + } + }, + removeEmpty: function removeEmpty(array) { + var ret = []; + for (var i = 0; i < array.length; i++) { + if (array[i]) { + ret.push(array[i]); + } + } + return ret; + }, + castInput: function castInput(value) { + return value; + }, + tokenize: function tokenize(value) { + return value.split(""); + }, + join: function join3(chars) { + return chars.join(""); + } +}; +function buildValues(diff2, components, newString, oldString, useLongestToken) { + var componentPos = 0, componentLen = components.length, newPos = 0, oldPos = 0; + for (; componentPos < componentLen; componentPos++) { + var component = components[componentPos]; + if (!component.removed) { + if (!component.added && useLongestToken) { + var value = newString.slice(newPos, newPos + component.count); + value = value.map(function(value2, i) { + var oldValue = oldString[oldPos + i]; + return oldValue.length > value2.length ? oldValue : value2; + }); + component.value = diff2.join(value); + } else { + component.value = diff2.join(newString.slice(newPos, newPos + component.count)); + } + newPos += component.count; + if (!component.added) { + oldPos += component.count; + } + } else { + component.value = diff2.join(oldString.slice(oldPos, oldPos + component.count)); + oldPos += component.count; + if (componentPos && components[componentPos - 1].added) { + var tmp = components[componentPos - 1]; + components[componentPos - 1] = components[componentPos]; + components[componentPos] = tmp; + } + } + } + var lastComponent = components[componentLen - 1]; + if (componentLen > 1 && typeof lastComponent.value === "string" && (lastComponent.added || lastComponent.removed) && diff2.equals("", lastComponent.value)) { + components[componentLen - 2].value += lastComponent.value; + components.pop(); + } + return components; +} +function clonePath(path2) { + return { + newPos: path2.newPos, + components: path2.components.slice(0) + }; +} +var characterDiff = new Diff(); +function diffChars(oldStr, newStr, options) { + return characterDiff.diff(oldStr, newStr, options); +} +var extendedWordChars = /^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/; +var reWhitespace = /\S/; +var wordDiff = new Diff(); +wordDiff.equals = function(left, right) { + if (this.options.ignoreCase) { + left = left.toLowerCase(); + right = right.toLowerCase(); + } + return left === right || this.options.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right); +}; +wordDiff.tokenize = function(value) { + var tokens = value.split(/([^\S\r\n]+|[()[\]{}'"\r\n]|\b)/); + for (var i = 0; i < tokens.length - 1; i++) { + if (!tokens[i + 1] && tokens[i + 2] && extendedWordChars.test(tokens[i]) && extendedWordChars.test(tokens[i + 2])) { + tokens[i] += tokens[i + 2]; + tokens.splice(i + 1, 2); + i--; + } + } + return tokens; +}; +function diffWordsWithSpace(oldStr, newStr, options) { + return wordDiff.diff(oldStr, newStr, options); +} +var lineDiff = new Diff(); +lineDiff.tokenize = function(value) { + var retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/); + if (!linesAndNewlines[linesAndNewlines.length - 1]) { + linesAndNewlines.pop(); + } + for (var i = 0; i < linesAndNewlines.length; i++) { + var line = linesAndNewlines[i]; + if (i % 2 && !this.options.newlineIsToken) { + retLines[retLines.length - 1] += line; + } else { + if (this.options.ignoreWhitespace) { + line = line.trim(); + } + retLines.push(line); + } + } + return retLines; +}; +function diffLines(oldStr, newStr, callback) { + return lineDiff.diff(oldStr, newStr, callback); +} +var sentenceDiff = new Diff(); +sentenceDiff.tokenize = function(value) { + return value.split(/(\S.+?[.!?])(?=\s+|$)/); +}; +var cssDiff = new Diff(); +cssDiff.tokenize = function(value) { + return value.split(/([{}:;,]|\s+)/); +}; +function _typeof(obj) { + "@babel/helpers - typeof"; + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function(obj2) { + return typeof obj2; + }; + } else { + _typeof = function(obj2) { + return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2; + }; + } + return _typeof(obj); +} +function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); +} +function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) + return _arrayLikeToArray(arr); +} +function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) + return Array.from(iter); +} +function _unsupportedIterableToArray(o, minLen) { + if (!o) + return; + if (typeof o === "string") + return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) + n = o.constructor.name; + if (n === "Map" || n === "Set") + return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) + return _arrayLikeToArray(o, minLen); +} +function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) + len = arr.length; + for (var i = 0, arr2 = new Array(len); i < len; i++) + arr2[i] = arr[i]; + return arr2; +} +function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} +var objectPrototypeToString = Object.prototype.toString; +var jsonDiff = new Diff(); +jsonDiff.useLongestToken = true; +jsonDiff.tokenize = lineDiff.tokenize; +jsonDiff.castInput = function(value) { + var _this$options = this.options, undefinedReplacement = _this$options.undefinedReplacement, _this$options$stringi = _this$options.stringifyReplacer, stringifyReplacer = _this$options$stringi === void 0 ? function(k, v) { + return typeof v === "undefined" ? undefinedReplacement : v; + } : _this$options$stringi; + return typeof value === "string" ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, " "); +}; +jsonDiff.equals = function(left, right) { + return Diff.prototype.equals.call(jsonDiff, left.replace(/,([\r\n])/g, "$1"), right.replace(/,([\r\n])/g, "$1")); +}; +function canonicalize(obj, stack, replacementStack, replacer, key2) { + stack = stack || []; + replacementStack = replacementStack || []; + if (replacer) { + obj = replacer(key2, obj); + } + var i; + for (i = 0; i < stack.length; i += 1) { + if (stack[i] === obj) { + return replacementStack[i]; + } + } + var canonicalizedObj; + if ("[object Array]" === objectPrototypeToString.call(obj)) { + stack.push(obj); + canonicalizedObj = new Array(obj.length); + replacementStack.push(canonicalizedObj); + for (i = 0; i < obj.length; i += 1) { + canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, key2); + } + stack.pop(); + replacementStack.pop(); + return canonicalizedObj; + } + if (obj && obj.toJSON) { + obj = obj.toJSON(); + } + if (_typeof(obj) === "object" && obj !== null) { + stack.push(obj); + canonicalizedObj = {}; + replacementStack.push(canonicalizedObj); + var sortedKeys = [], _key; + for (_key in obj) { + if (obj.hasOwnProperty(_key)) { + sortedKeys.push(_key); + } + } + sortedKeys.sort(); + for (i = 0; i < sortedKeys.length; i += 1) { + _key = sortedKeys[i]; + canonicalizedObj[_key] = canonicalize(obj[_key], stack, replacementStack, replacer, _key); + } + stack.pop(); + replacementStack.pop(); + } else { + canonicalizedObj = obj; + } + return canonicalizedObj; +} +var arrayDiff = new Diff(); +arrayDiff.tokenize = function(value) { + return value.slice(); +}; +arrayDiff.join = arrayDiff.removeEmpty = function(value) { + return value; +}; +function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) { + if (!options) { + options = {}; + } + if (typeof options.context === "undefined") { + options.context = 4; + } + var diff2 = diffLines(oldStr, newStr, options); + if (!diff2) { + return; + } + diff2.push({ + value: "", + lines: [] + }); + function contextLines(lines) { + return lines.map(function(entry) { + return " " + entry; + }); + } + var hunks = []; + var oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1; + var _loop = function _loop2(i2) { + var current = diff2[i2], lines = current.lines || current.value.replace(/\n$/, "").split("\n"); + current.lines = lines; + if (current.added || current.removed) { + var _curRange; + if (!oldRangeStart) { + var prev = diff2[i2 - 1]; + oldRangeStart = oldLine; + newRangeStart = newLine; + if (prev) { + curRange = options.context > 0 ? contextLines(prev.lines.slice(-options.context)) : []; + oldRangeStart -= curRange.length; + newRangeStart -= curRange.length; + } + } + (_curRange = curRange).push.apply(_curRange, _toConsumableArray(lines.map(function(entry) { + return (current.added ? "+" : "-") + entry; + }))); + if (current.added) { + newLine += lines.length; + } else { + oldLine += lines.length; + } + } else { + if (oldRangeStart) { + if (lines.length <= options.context * 2 && i2 < diff2.length - 2) { + var _curRange2; + (_curRange2 = curRange).push.apply(_curRange2, _toConsumableArray(contextLines(lines))); + } else { + var _curRange3; + var contextSize = Math.min(lines.length, options.context); + (_curRange3 = curRange).push.apply(_curRange3, _toConsumableArray(contextLines(lines.slice(0, contextSize)))); + var hunk = { + oldStart: oldRangeStart, + oldLines: oldLine - oldRangeStart + contextSize, + newStart: newRangeStart, + newLines: newLine - newRangeStart + contextSize, + lines: curRange + }; + if (i2 >= diff2.length - 2 && lines.length <= options.context) { + var oldEOFNewline = /\n$/.test(oldStr); + var newEOFNewline = /\n$/.test(newStr); + var noNlBeforeAdds = lines.length == 0 && curRange.length > hunk.oldLines; + if (!oldEOFNewline && noNlBeforeAdds && oldStr.length > 0) { + curRange.splice(hunk.oldLines, 0, "\\ No newline at end of file"); + } + if (!oldEOFNewline && !noNlBeforeAdds || !newEOFNewline) { + curRange.push("\\ No newline at end of file"); + } + } + hunks.push(hunk); + oldRangeStart = 0; + newRangeStart = 0; + curRange = []; + } + } + oldLine += lines.length; + newLine += lines.length; + } + }; + for (var i = 0; i < diff2.length; i++) { + _loop(i); + } + return { + oldFileName, + newFileName, + oldHeader, + newHeader, + hunks + }; +} +function formatPatch(diff2) { + var ret = []; + if (diff2.oldFileName == diff2.newFileName) { + ret.push("Index: " + diff2.oldFileName); + } + ret.push("==================================================================="); + ret.push("--- " + diff2.oldFileName + (typeof diff2.oldHeader === "undefined" ? "" : " " + diff2.oldHeader)); + ret.push("+++ " + diff2.newFileName + (typeof diff2.newHeader === "undefined" ? "" : " " + diff2.newHeader)); + for (var i = 0; i < diff2.hunks.length; i++) { + var hunk = diff2.hunks[i]; + if (hunk.oldLines === 0) { + hunk.oldStart -= 1; + } + if (hunk.newLines === 0) { + hunk.newStart -= 1; + } + ret.push("@@ -" + hunk.oldStart + "," + hunk.oldLines + " +" + hunk.newStart + "," + hunk.newLines + " @@"); + ret.push.apply(ret, hunk.lines); + } + return ret.join("\n") + "\n"; +} +function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) { + return formatPatch(structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options)); +} +function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) { + return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options); +} + +// src/gitManager/isomorphicGit.ts +var import_obsidian7 = require("obsidian"); + +// src/ui/modals/generalModal.ts +init_polyfill_buffer(); +var import_obsidian5 = require("obsidian"); +var generalModalConfigDefaults = { + options: [], + placeholder: "", + allowEmpty: false, + onlySelection: false, + initialValue: void 0 +}; +var GeneralModal = class extends import_obsidian5.SuggestModal { + constructor(config) { + super(app); + this.config = { ...generalModalConfigDefaults, ...config }; + this.setPlaceholder(this.config.placeholder); + } + open() { + super.open(); + if (this.config.initialValue != void 0) { + this.inputEl.value = this.config.initialValue; + this.inputEl.dispatchEvent(new Event("input")); + } + return new Promise((resolve) => { + this.resolve = resolve; + }); + } + selectSuggestion(value, evt) { + if (this.resolve) { + let res; + if (this.config.allowEmpty && value === " ") + res = ""; + else if (value === "...") + res = void 0; + else + res = value; + this.resolve(res); + } + super.selectSuggestion(value, evt); + } + onClose() { + if (this.resolve) + this.resolve(void 0); + } + getSuggestions(query) { + if (this.config.onlySelection) { + return this.config.options; + } else if (this.config.allowEmpty) { + return [query.length > 0 ? query : " ", ...this.config.options]; + } else { + return [query.length > 0 ? query : "...", ...this.config.options]; + } + } + renderSuggestion(value, el) { + el.setText(value); + } + onChooseSuggestion(item, evt) { + } +}; + +// src/gitManager/myAdapter.ts +init_polyfill_buffer(); +var import_obsidian6 = require("obsidian"); +var MyAdapter = class { + constructor(vault, plugin) { + this.plugin = plugin; + this.promises = {}; + this.adapter = vault.adapter; + this.vault = vault; + this.lastBasePath = this.plugin.settings.basePath; + this.promises.readFile = this.readFile.bind(this); + this.promises.writeFile = this.writeFile.bind(this); + this.promises.readdir = this.readdir.bind(this); + this.promises.mkdir = this.mkdir.bind(this); + this.promises.rmdir = this.rmdir.bind(this); + this.promises.stat = this.stat.bind(this); + this.promises.unlink = this.unlink.bind(this); + this.promises.lstat = this.lstat.bind(this); + this.promises.readlink = this.readlink.bind(this); + this.promises.symlink = this.symlink.bind(this); + } + async readFile(path2, opts) { + var _a2; + this.maybeLog("Read: " + path2 + JSON.stringify(opts)); + if (opts == "utf8" || opts.encoding == "utf8") { + const file = this.vault.getAbstractFileByPath(path2); + if (file instanceof import_obsidian6.TFile) { + this.maybeLog("Reuse"); + return this.vault.read(file); + } else { + return this.adapter.read(path2); + } + } else { + if (path2.endsWith(this.gitDir + "/index")) { + if (this.plugin.settings.basePath != this.lastBasePath) { + this.clearIndex(); + this.lastBasePath = this.plugin.settings.basePath; + return this.adapter.readBinary(path2); + } + return (_a2 = this.index) != null ? _a2 : this.adapter.readBinary(path2); + } + const file = this.vault.getAbstractFileByPath(path2); + if (file instanceof import_obsidian6.TFile) { + this.maybeLog("Reuse"); + return this.vault.readBinary(file); + } else { + return this.adapter.readBinary(path2); + } + } + } + async writeFile(path2, data) { + this.maybeLog("Write: " + path2); + if (typeof data === "string") { + const file = this.vault.getAbstractFileByPath(path2); + if (file instanceof import_obsidian6.TFile) { + return this.vault.modify(file, data); + } else { + return this.adapter.write(path2, data); + } + } else { + if (path2.endsWith(this.gitDir + "/index")) { + this.index = data; + this.indexmtime = Date.now(); + } else { + const file = this.vault.getAbstractFileByPath(path2); + if (file instanceof import_obsidian6.TFile) { + return this.vault.modifyBinary(file, data); + } else { + return this.adapter.writeBinary(path2, data); + } + } + } + } + async readdir(path2) { + if (path2 === ".") + path2 = "/"; + const res = await this.adapter.list(path2); + const all = [...res.files, ...res.folders]; + let formattedAll; + if (path2 !== "/") { + formattedAll = all.map( + (e) => (0, import_obsidian6.normalizePath)(e.substring(path2.length)) + ); + } else { + formattedAll = all; + } + return formattedAll; + } + async mkdir(path2) { + return this.adapter.mkdir(path2); + } + async rmdir(path2, opts) { + var _a2, _b; + return this.adapter.rmdir(path2, (_b = (_a2 = opts == null ? void 0 : opts.options) == null ? void 0 : _a2.recursive) != null ? _b : false); + } + async stat(path2) { + if (path2.endsWith(this.gitDir + "/index")) { + if (this.index !== void 0 && this.indexctime != void 0 && this.indexmtime != void 0) { + return { + isFile: () => true, + isDirectory: () => false, + isSymbolicLink: () => false, + size: this.index.length, + type: "file", + ctimeMs: this.indexctime, + mtimeMs: this.indexmtime + }; + } else { + const stat = await this.adapter.stat(path2); + if (stat == void 0) { + throw { code: "ENOENT" }; + } + this.indexctime = stat.ctime; + this.indexmtime = stat.mtime; + return { + ctimeMs: stat.ctime, + mtimeMs: stat.mtime, + size: stat.size, + type: "file", + isFile: () => true, + isDirectory: () => false, + isSymbolicLink: () => false + }; + } + } + if (path2 === ".") + path2 = "/"; + const file = this.vault.getAbstractFileByPath(path2); + this.maybeLog("Stat: " + path2); + if (file instanceof import_obsidian6.TFile) { + this.maybeLog("Reuse stat"); + return { + ctimeMs: file.stat.ctime, + mtimeMs: file.stat.mtime, + size: file.stat.size, + type: "file", + isFile: () => true, + isDirectory: () => false, + isSymbolicLink: () => false + }; + } else { + const stat = await this.adapter.stat(path2); + if (stat) { + return { + ctimeMs: stat.ctime, + mtimeMs: stat.mtime, + size: stat.size, + type: stat.type === "folder" ? "directory" : stat.type, + isFile: () => stat.type === "file", + isDirectory: () => stat.type === "folder", + isSymbolicLink: () => false + }; + } else { + throw { code: "ENOENT" }; + } + } + } + async unlink(path2) { + return this.adapter.remove(path2); + } + async lstat(path2) { + return this.stat(path2); + } + async readlink(path2) { + throw new Error(`readlink of (${path2}) is not implemented.`); + } + async symlink(path2) { + throw new Error(`symlink of (${path2}) is not implemented.`); + } + async saveAndClear() { + if (this.index !== void 0) { + await this.adapter.writeBinary( + this.plugin.gitManager.getVaultPath(this.gitDir + "/index"), + this.index, + { + ctime: this.indexctime, + mtime: this.indexmtime + } + ); + } + this.clearIndex(); + } + clearIndex() { + this.index = void 0; + this.indexctime = void 0; + this.indexmtime = void 0; + } + get gitDir() { + return this.plugin.settings.gitDir || ".git"; + } + maybeLog(text2) { + } +}; + +// src/gitManager/isomorphicGit.ts +var IsomorphicGit = class extends GitManager { + constructor(plugin) { + super(plugin); + this.FILE = 0; + this.HEAD = 1; + this.WORKDIR = 2; + this.STAGE = 3; + // Mapping from statusMatrix to git status codes based off git status --short + // See: https://isomorphic-git.org/docs/en/statusMatrix + this.status_mapping = { + "000": " ", + "003": "AD", + "020": "??", + "022": "A ", + "023": "AM", + "100": "D ", + "101": " D", + "103": "MD", + "110": "DA", + // Technically, two files: first one is deleted "D " and second one is untracked "??" + "111": " ", + "113": "MM", + "120": "DA", + // Same as "110" + "121": " M", + "122": "M ", + "123": "MM" + }; + this.noticeLength = 999999; + this.fs = new MyAdapter(this.app.vault, this.plugin); + } + getRepo() { + return { + fs: this.fs, + dir: this.plugin.settings.basePath, + gitdir: this.plugin.settings.gitDir || void 0, + onAuth: () => { + var _a2, _b; + return { + username: (_a2 = this.plugin.localStorage.getUsername()) != null ? _a2 : void 0, + password: (_b = this.plugin.localStorage.getPassword()) != null ? _b : void 0 + }; + }, + onAuthFailure: async () => { + new import_obsidian7.Notice( + "Authentication failed. Please try with different credentials" + ); + const username = await new GeneralModal({ + placeholder: "Specify your username" + }).open(); + if (username) { + const password = await new GeneralModal({ + placeholder: "Specify your password/personal access token" + }).open(); + if (password) { + this.plugin.localStorage.setUsername(username); + this.plugin.localStorage.setPassword(password); + return { + username, + password + }; + } + } + return { cancel: true }; + }, + http: { + async request({ + url, + method: method2, + headers, + body + }) { + if (body) { + body = await collect2(body); + body = body.buffer; + } + const res = await (0, import_obsidian7.requestUrl)({ + url, + method: method2, + headers, + body, + throw: false + }); + return { + url, + method: method2, + headers: res.headers, + body: [new Uint8Array(res.arrayBuffer)], + statusCode: res.status, + statusMessage: res.status.toString() + }; + } + } + }; + } + async wrapFS(call) { + try { + const res = await call; + await this.fs.saveAndClear(); + return res; + } catch (error) { + await this.fs.saveAndClear(); + throw error; + } + } + async status() { + let notice; + const timeout = window.setTimeout(function() { + notice = new import_obsidian7.Notice( + "This takes longer: Getting status", + this.noticeLength + ); + }, 2e4); + try { + this.plugin.setState(1 /* status */); + const status2 = (await this.wrapFS(isomorphic_git_default.statusMatrix({ ...this.getRepo() }))).map((row) => this.getFileStatusResult(row)); + const changed = status2.filter( + (fileStatus) => fileStatus.working_dir !== " " + ); + const staged = status2.filter( + (fileStatus) => fileStatus.index !== " " && fileStatus.index !== "U" + ); + const conflicted = []; + window.clearTimeout(timeout); + notice == null ? void 0 : notice.hide(); + return { changed, staged, conflicted }; + } catch (error) { + window.clearTimeout(timeout); + notice == null ? void 0 : notice.hide(); + this.plugin.displayError(error); + throw error; + } + } + async commitAll({ + message, + status: status2, + unstagedFiles + }) { + try { + await this.checkAuthorInfo(); + await this.stageAll({ status: status2, unstagedFiles }); + return this.commit(message); + } catch (error) { + this.plugin.displayError(error); + throw error; + } + } + async commit(message) { + try { + await this.checkAuthorInfo(); + this.plugin.setState(4 /* commit */); + const formatMessage = await this.formatCommitMessage(message); + const hadConflict = this.plugin.localStorage.getConflict() === "true"; + let parent = void 0; + if (hadConflict) { + const branchInfo = await this.branchInfo(); + parent = [branchInfo.current, branchInfo.tracking]; + } + await this.wrapFS( + isomorphic_git_default.commit({ + ...this.getRepo(), + message: formatMessage, + parent + }) + ); + this.plugin.localStorage.setConflict("false"); + return; + } catch (error) { + this.plugin.displayError(error); + throw error; + } + } + async stage(filepath, relativeToVault) { + const gitPath = this.asRepositoryRelativePath( + filepath, + relativeToVault + ); + let vaultPath; + if (relativeToVault) { + vaultPath = filepath; + } else { + vaultPath = this.getVaultPath(filepath); + } + try { + this.plugin.setState(3 /* add */); + if (await this.app.vault.adapter.exists(vaultPath)) { + await this.wrapFS( + isomorphic_git_default.add({ ...this.getRepo(), filepath: gitPath }) + ); + } else { + await this.wrapFS( + isomorphic_git_default.remove({ ...this.getRepo(), filepath: gitPath }) + ); + } + } catch (error) { + this.plugin.displayError(error); + throw error; + } + } + async stageAll({ + dir, + status: status2, + unstagedFiles + }) { + try { + if (status2) { + await Promise.all( + status2.changed.map( + (file) => file.working_dir !== "D" ? this.wrapFS( + isomorphic_git_default.add({ + ...this.getRepo(), + filepath: file.path + }) + ) : isomorphic_git_default.remove({ + ...this.getRepo(), + filepath: file.path + }) + ) + ); + } else { + const filesToStage = unstagedFiles != null ? unstagedFiles : await this.getUnstagedFiles(dir != null ? dir : "."); + await Promise.all( + filesToStage.map( + ({ filepath, deleted }) => deleted ? isomorphic_git_default.remove({ ...this.getRepo(), filepath }) : this.wrapFS( + isomorphic_git_default.add({ ...this.getRepo(), filepath }) + ) + ) + ); + } + } catch (error) { + this.plugin.displayError(error); + throw error; + } + } + async unstage(filepath, relativeToVault) { + try { + this.plugin.setState(3 /* add */); + filepath = this.asRepositoryRelativePath(filepath, relativeToVault); + await this.wrapFS( + isomorphic_git_default.resetIndex({ ...this.getRepo(), filepath }) + ); + } catch (error) { + this.plugin.displayError(error); + throw error; + } + } + async unstageAll({ + dir, + status: status2 + }) { + try { + let staged; + if (status2) { + staged = status2.staged.map((file) => file.path); + } else { + const res = await this.getStagedFiles(dir != null ? dir : "."); + staged = res.map(({ filepath }) => filepath); + } + await this.wrapFS( + Promise.all( + staged.map( + (file) => isomorphic_git_default.resetIndex({ ...this.getRepo(), filepath: file }) + ) + ) + ); + } catch (error) { + this.plugin.displayError(error); + throw error; + } + } + async discard(filepath) { + try { + this.plugin.setState(3 /* add */); + await this.wrapFS( + isomorphic_git_default.checkout({ + ...this.getRepo(), + filepaths: [filepath], + force: true + }) + ); + } catch (error) { + this.plugin.displayError(error); + throw error; + } + } + async discardAll({ + dir, + status: status2 + }) { + let files = []; + if (status2) { + if (dir != void 0) { + files = status2.changed.filter((file) => file.path.startsWith(dir)).map((file) => file.path); + } else { + files = status2.changed.map((file) => file.path); + } + } else { + files = (await this.getUnstagedFiles(dir)).map( + ({ filepath }) => filepath + ); + } + try { + await this.wrapFS( + isomorphic_git_default.checkout({ + ...this.getRepo(), + filepaths: files, + force: true + }) + ); + } catch (error) { + this.plugin.displayError(error); + throw error; + } + } + getProgressText(action, event) { + let out = `${action} progress:`; + if (event.phase) { + out = `${out} ${event.phase}:`; + } + if (event.loaded) { + out = `${out} ${event.loaded}`; + if (event.total) { + out = `${out} of ${event.total}`; + } + } + return out; + } + resolveRef(ref) { + return this.wrapFS(isomorphic_git_default.resolveRef({ ...this.getRepo(), ref })); + } + async pull() { + const progressNotice = this.showNotice("Initializing pull"); + try { + this.plugin.setState(2 /* pull */); + const localCommit = await this.resolveRef("HEAD"); + await this.fetch(); + const branchInfo = await this.branchInfo(); + await this.checkAuthorInfo(); + const mergeRes = await this.wrapFS( + isomorphic_git_default.merge({ + ...this.getRepo(), + ours: branchInfo.current, + theirs: branchInfo.tracking, + abortOnConflict: false + }) + ); + if (!mergeRes.alreadyMerged) { + await this.wrapFS( + isomorphic_git_default.checkout({ + ...this.getRepo(), + ref: branchInfo.current, + onProgress: (progress) => { + if (progressNotice !== void 0) { + progressNotice.noticeEl.innerText = this.getProgressText("Checkout", progress); + } + }, + remote: branchInfo.remote + }) + ); + } + progressNotice == null ? void 0 : progressNotice.hide(); + const upstreamCommit = await this.resolveRef("HEAD"); + const changedFiles = await this.getFileChangesCount( + localCommit, + upstreamCommit + ); + this.showNotice("Finished pull", false); + return changedFiles.map((file) => ({ + path: file.path, + working_dir: "P", + index: "P", + vault_path: this.getVaultPath(file.path) + })); + } catch (error) { + progressNotice == null ? void 0 : progressNotice.hide(); + if (error instanceof Errors.MergeConflictError) { + this.plugin.handleConflict( + error.data.filepaths.map((file) => this.getVaultPath(file)) + ); + } + this.plugin.displayError(error); + throw error; + } + } + async push() { + if (!await this.canPush()) { + return 0; + } + const progressNotice = this.showNotice("Initializing push"); + try { + this.plugin.setState(1 /* status */); + const status2 = await this.branchInfo(); + const trackingBranch = status2.tracking; + const currentBranch2 = status2.current; + const numChangedFiles = (await this.getFileChangesCount(currentBranch2, trackingBranch)).length; + this.plugin.setState(5 /* push */); + await this.wrapFS( + isomorphic_git_default.push({ + ...this.getRepo(), + onProgress: (progress) => { + if (progressNotice !== void 0) { + progressNotice.noticeEl.innerText = this.getProgressText("Pushing", progress); + } + } + }) + ); + progressNotice == null ? void 0 : progressNotice.hide(); + return numChangedFiles; + } catch (error) { + progressNotice == null ? void 0 : progressNotice.hide(); + this.plugin.displayError(error); + throw error; + } + } + async getUnpushedCommits() { + const status2 = await this.branchInfo(); + const trackingBranch = status2.tracking; + const currentBranch2 = status2.current; + if (trackingBranch == null || currentBranch2 == null) { + return 0; + } + const localCommit = await this.resolveRef(currentBranch2); + const upstreamCommit = await this.resolveRef(trackingBranch); + const changedFiles = await this.getFileChangesCount( + localCommit, + upstreamCommit + ); + return changedFiles.length; + } + async canPush() { + const status2 = await this.branchInfo(); + const trackingBranch = status2.tracking; + const currentBranch2 = status2.current; + const current = await this.resolveRef(currentBranch2); + const tracking = await this.resolveRef(trackingBranch); + return current != tracking; + } + async checkRequirements() { + const headExists = await this.plugin.app.vault.adapter.exists( + `${this.getRepo().dir}/.git/HEAD` + ); + return headExists ? "valid" : "missing-repo"; + } + async branchInfo() { + var _a2, _b; + try { + const current = await isomorphic_git_default.currentBranch(this.getRepo()) || ""; + const branches = await isomorphic_git_default.listBranches(this.getRepo()); + const remote = (_a2 = await this.getConfig(`branch.${current}.remote`)) != null ? _a2 : "origin"; + const trackingBranch = (_b = await this.getConfig(`branch.${current}.merge`)) == null ? void 0 : _b.split("refs/heads")[1]; + const tracking = trackingBranch ? remote + trackingBranch : void 0; + return { + current, + tracking, + branches, + remote + }; + } catch (error) { + this.plugin.displayError(error); + throw error; + } + } + async getCurrentRemote() { + var _a2; + const current = await isomorphic_git_default.currentBranch(this.getRepo()) || ""; + const remote = (_a2 = await this.getConfig(`branch.${current}.remote`)) != null ? _a2 : "origin"; + return remote; + } + async checkout(branch2, remote) { + try { + return this.wrapFS( + isomorphic_git_default.checkout({ + ...this.getRepo(), + ref: branch2, + force: !!remote, + remote + }) + ); + } catch (error) { + this.plugin.displayError(error); + throw error; + } + } + async createBranch(branch2) { + try { + await this.wrapFS( + isomorphic_git_default.branch({ ...this.getRepo(), ref: branch2, checkout: true }) + ); + } catch (error) { + this.plugin.displayError(error); + throw error; + } + } + async deleteBranch(branch2) { + try { + await this.wrapFS( + isomorphic_git_default.deleteBranch({ ...this.getRepo(), ref: branch2 }) + ); + } catch (error) { + this.plugin.displayError(error); + throw error; + } + } + async branchIsMerged(branch2) { + return true; + } + async init() { + try { + await this.wrapFS(isomorphic_git_default.init(this.getRepo())); + } catch (error) { + this.plugin.displayError(error); + throw error; + } + } + async clone(url, dir, depth) { + const progressNotice = this.showNotice("Initializing clone"); + try { + await this.wrapFS( + isomorphic_git_default.clone({ + ...this.getRepo(), + dir, + url, + depth, + onProgress: (progress) => { + if (progressNotice !== void 0) { + progressNotice.noticeEl.innerText = this.getProgressText("Cloning", progress); + } + } + }) + ); + progressNotice == null ? void 0 : progressNotice.hide(); + } catch (error) { + progressNotice == null ? void 0 : progressNotice.hide(); + this.plugin.displayError(error); + throw error; + } + } + async setConfig(path2, value) { + try { + return this.wrapFS( + isomorphic_git_default.setConfig({ + ...this.getRepo(), + path: path2, + value + }) + ); + } catch (error) { + this.plugin.displayError(error); + throw error; + } + } + async getConfig(path2) { + try { + return this.wrapFS( + isomorphic_git_default.getConfig({ + ...this.getRepo(), + path: path2 + }) + ); + } catch (error) { + this.plugin.displayError(error); + throw error; + } + } + async fetch(remote) { + const progressNotice = this.showNotice("Initializing fetch"); + try { + const args = { + ...this.getRepo(), + onProgress: (progress) => { + if (progressNotice !== void 0) { + progressNotice.noticeEl.innerText = this.getProgressText("Fetching", progress); + } + }, + remote: remote != null ? remote : await this.getCurrentRemote() + }; + await this.wrapFS(isomorphic_git_default.fetch(args)); + progressNotice == null ? void 0 : progressNotice.hide(); + } catch (error) { + this.plugin.displayError(error); + progressNotice == null ? void 0 : progressNotice.hide(); + throw error; + } + } + async setRemote(name, url) { + try { + await this.wrapFS( + isomorphic_git_default.addRemote({ + ...this.getRepo(), + remote: name, + url, + force: true + }) + ); + } catch (error) { + this.plugin.displayError(error); + throw error; + } + } + async getRemoteBranches(remote) { + let remoteBranches = []; + remoteBranches.push( + ...await this.wrapFS( + isomorphic_git_default.listBranches({ ...this.getRepo(), remote }) + ) + ); + remoteBranches.remove("HEAD"); + remoteBranches = remoteBranches.map((e) => `${remote}/${e}`); + return remoteBranches; + } + async getRemotes() { + return (await this.wrapFS(isomorphic_git_default.listRemotes({ ...this.getRepo() }))).map( + (remoteUrl) => remoteUrl.remote + ); + } + async removeRemote(remoteName) { + await this.wrapFS( + isomorphic_git_default.deleteRemote({ ...this.getRepo(), remote: remoteName }) + ); + } + async getRemoteUrl(remote) { + var _a2; + return (_a2 = (await this.wrapFS(isomorphic_git_default.listRemotes({ ...this.getRepo() }))).filter((item) => item.remote == remote)[0]) == null ? void 0 : _a2.url; + } + async log(_, __ = true, limit) { + const logs = await this.wrapFS( + isomorphic_git_default.log({ ...this.getRepo(), depth: limit }) + ); + return Promise.all( + logs.map(async (log2) => { + const completeMessage = log2.commit.message.split("\n\n"); + return { + message: completeMessage[0], + body: completeMessage.slice(1).join("\n\n"), + date: new Date( + log2.commit.committer.timestamp + ).toDateString(), + diff: { + changed: 0, + files: (await this.getFileChangesCount( + log2.commit.parent.first(), + log2.oid + )).map((item) => { + return { + path: item.path, + status: item.type, + vault_path: this.getVaultPath(item.path), + hash: log2.oid, + binary: void 0 + }; + }) + }, + hash: log2.oid, + refs: [] + }; + }) + ); + } + updateBasePath(basePath) { + this.getRepo().dir = basePath; + } + async updateUpstreamBranch(remoteBranch) { + const [remote, branch2] = splitRemoteBranch(remoteBranch); + const branchInfo = await this.branchInfo(); + await this.setConfig( + `branch.${branchInfo.current}.merge`, + `refs/heads/${branch2}` + ); + await this.setConfig(`branch.${branch2}.remote`, remote); + } + updateGitPath(gitPath) { + return; + } + async getFileChangesCount(commitHash1, commitHash2) { + return this.walkDifference({ + walkers: [ + isomorphic_git_default.TREE({ ref: commitHash1 }), + isomorphic_git_default.TREE({ ref: commitHash2 }) + ] + }); + } + async walkDifference({ + walkers, + dir: base + }) { + const res = await this.wrapFS( + isomorphic_git_default.walk({ + ...this.getRepo(), + trees: walkers, + map: async function(filepath, [A, B]) { + if (!worthWalking2(filepath, base)) { + return null; + } + if (await (A == null ? void 0 : A.type()) === "tree" || await (B == null ? void 0 : B.type()) === "tree") { + return; + } + const Aoid = await (A == null ? void 0 : A.oid()); + const Boid = await (B == null ? void 0 : B.oid()); + let type = "equal"; + if (Aoid !== Boid) { + type = "M"; + } + if (Aoid === void 0) { + type = "A"; + } + if (Boid === void 0) { + type = "D"; + } + if (Aoid === void 0 && Boid === void 0) { + console.log("Something weird happened:"); + console.log(A); + console.log(B); + } + if (type === "equal") { + return; + } + return { + path: filepath, + type + }; + } + }) + ); + return res; + } + async getStagedFiles(dir = ".") { + const res = await this.walkDifference({ + walkers: [isomorphic_git_default.TREE({ ref: "HEAD" }), isomorphic_git_default.STAGE()], + dir + }); + return res.map((file) => { + return { + vault_path: this.getVaultPath(file.path), + filepath: file.path + }; + }); + } + async getUnstagedFiles(base = ".") { + let notice; + const timeout = window.setTimeout(function() { + notice = new import_obsidian7.Notice( + "This takes longer: Getting status", + this.noticeLength + ); + }, 2e4); + try { + const repo = this.getRepo(); + const res = await this.wrapFS( + //Modified from `git.statusMatrix` + isomorphic_git_default.walk({ + ...repo, + trees: [isomorphic_git_default.WORKDIR(), isomorphic_git_default.STAGE()], + map: async function(filepath, [workdir, stage]) { + if (!stage && workdir) { + const isIgnored2 = await isomorphic_git_default.isIgnored({ + ...repo, + filepath + }); + if (isIgnored2) { + return null; + } + } + if (!worthWalking2(filepath, base)) { + return null; + } + const [workdirType, stageType] = await Promise.all([ + workdir && workdir.type(), + stage && stage.type() + ]); + const isBlob = [workdirType, stageType].includes( + "blob" + ); + if ((workdirType === "tree" || workdirType === "special") && !isBlob) + return; + if (stageType === "commit") + return null; + if ((stageType === "tree" || stageType === "special") && !isBlob) + return; + const stageOid = stageType === "blob" ? await stage.oid() : void 0; + let workdirOid; + if (workdirType === "blob" && stageType !== "blob") { + workdirOid = "42"; + } else if (workdirType === "blob") { + workdirOid = await workdir.oid(); + } + if (!workdirOid) { + return { + filepath, + deleted: true + }; + } + if (workdirOid !== stageOid) { + return { + filepath, + deleted: false + }; + } + return null; + } + }) + ); + window.clearTimeout(timeout); + notice == null ? void 0 : notice.hide(); + return res; + } catch (error) { + window.clearTimeout(timeout); + notice == null ? void 0 : notice.hide(); + this.plugin.displayError(error); + throw error; + } + } + async getDiffString(filePath, stagedChanges = false, hash2) { + const vaultPath = this.getVaultPath(filePath); + const map = async (file, [A]) => { + if (filePath == file) { + const oid = await A.oid(); + const contents = await isomorphic_git_default.readBlob({ + ...this.getRepo(), + oid + }); + return contents.blob; + } + }; + if (hash2) { + const commitContent = await readBlob({ + ...this.getRepo(), + filepath: filePath, + oid: hash2 + }).then((headBlob) => new TextDecoder().decode(headBlob.blob)).catch((err) => { + if (err instanceof isomorphic_git_default.Errors.NotFoundError) + return void 0; + throw err; + }); + const commit2 = await isomorphic_git_default.readCommit({ + ...this.getRepo(), + oid: hash2 + }); + const previousContent = await readBlob({ + ...this.getRepo(), + filepath: filePath, + oid: commit2.commit.parent.first() + }).then((headBlob) => new TextDecoder().decode(headBlob.blob)).catch((err) => { + if (err instanceof isomorphic_git_default.Errors.NotFoundError) + return void 0; + throw err; + }); + const diff2 = createPatch( + vaultPath, + previousContent != null ? previousContent : "", + commitContent != null ? commitContent : "" + ); + return diff2; + } + const stagedBlob = (await isomorphic_git_default.walk({ + ...this.getRepo(), + trees: [isomorphic_git_default.STAGE()], + map + })).first(); + const stagedContent = new TextDecoder().decode(stagedBlob); + if (stagedChanges) { + const headContent = await this.resolveRef("HEAD").then( + (oid) => readBlob({ + ...this.getRepo(), + filepath: filePath, + oid + }) + ).then((headBlob) => new TextDecoder().decode(headBlob.blob)).catch((err) => { + if (err instanceof isomorphic_git_default.Errors.NotFoundError) + return void 0; + throw err; + }); + const diff2 = createPatch( + vaultPath, + headContent != null ? headContent : "", + stagedContent + ); + return diff2; + } else { + let workdirContent; + if (await app.vault.adapter.exists(vaultPath)) { + workdirContent = await app.vault.adapter.read(vaultPath); + } else { + workdirContent = ""; + } + const diff2 = createPatch(vaultPath, stagedContent, workdirContent); + return diff2; + } + } + async getLastCommitTime() { + const repo = this.getRepo(); + const oid = await this.resolveRef("HEAD"); + const commit2 = await isomorphic_git_default.readCommit({ ...repo, oid }); + const date = commit2.commit.committer.timestamp; + return new Date(date * 1e3); + } + getFileStatusResult(row) { + const status2 = this.status_mapping[`${row[this.HEAD]}${row[this.WORKDIR]}${row[this.STAGE]}`]; + return { + index: status2[0] == "?" ? "U" : status2[0], + working_dir: status2[1] == "?" ? "U" : status2[1], + path: row[this.FILE], + vault_path: this.getVaultPath(row[this.FILE]) + }; + } + async checkAuthorInfo() { + const name = await this.getConfig("user.name"); + const email = await this.getConfig("user.email"); + if (!name || !email) { + throw "Git author information is not set. Please set it in the settings."; + } + } + showNotice(message, infinity = true) { + if (!this.plugin.settings.disablePopups) { + return new import_obsidian7.Notice( + message, + infinity ? this.noticeLength : void 0 + ); + } + } +}; +function fromValue2(value) { + let queue = [value]; + return { + next() { + return Promise.resolve({ + done: queue.length === 0, + value: queue.pop() + }); + }, + return() { + queue = []; + return {}; + }, + [Symbol.asyncIterator]() { + return this; + } + }; +} +function getIterator2(iterable) { + if (iterable[Symbol.asyncIterator]) { + return iterable[Symbol.asyncIterator](); + } + if (iterable[Symbol.iterator]) { + return iterable[Symbol.iterator](); + } + if (iterable.next) { + return iterable; + } + return fromValue2(iterable); +} +async function forAwait2(iterable, cb) { + const iter = getIterator2(iterable); + while (true) { + const { value, done } = await iter.next(); + if (value) + await cb(value); + if (done) + break; + } + if (iter.return) + iter.return(); +} +async function collect2(iterable) { + let size = 0; + const buffers = []; + await forAwait2(iterable, (value) => { + buffers.push(value); + size += value.byteLength; + }); + const result = new Uint8Array(size); + let nextIndex = 0; + for (const buffer2 of buffers) { + result.set(buffer2, nextIndex); + nextIndex += buffer2.byteLength; + } + return result; +} + +// src/setting/settings.ts +var FORMAT_STRING_REFERENCE_URL = "https://momentjs.com/docs/#/parsing/string-format/"; +var LINE_AUTHOR_FEATURE_WIKI_LINK = "https://publish.obsidian.md/git-doc/Line+Authoring"; +var ObsidianGitSettingsTab = class extends import_obsidian8.PluginSettingTab { + constructor() { + super(...arguments); + this.lineAuthorColorSettings = /* @__PURE__ */ new Map(); + } + // narrow type from PluginSettingTab.plugin + get settings() { + return this.plugin.settings; + } + display() { + const { containerEl } = this; + const plugin = this.plugin; + const commitOrBackup = plugin.settings.differentIntervalCommitAndPush ? "commit" : "backup"; + const gitReady = plugin.gitReady; + containerEl.empty(); + containerEl.createEl("h2", { text: "Git Backup settings" }); + if (!gitReady) { + containerEl.createEl("p", { + text: "Git is not ready. When all settings are correct you can configure auto backup, etc." + }); + } + if (gitReady) { + containerEl.createEl("br"); + containerEl.createEl("h3", { text: "Automatic" }); + new import_obsidian8.Setting(containerEl).setName("Split automatic commit and push").setDesc("Enable to use separate timer for commit and push").addToggle( + (toggle) => toggle.setValue( + plugin.settings.differentIntervalCommitAndPush + ).onChange((value) => { + plugin.settings.differentIntervalCommitAndPush = value; + plugin.saveSettings(); + plugin.clearAutoBackup(); + plugin.clearAutoPush(); + if (plugin.settings.autoSaveInterval > 0) { + plugin.startAutoBackup( + plugin.settings.autoSaveInterval + ); + } + if (value && plugin.settings.autoPushInterval > 0) { + plugin.startAutoPush( + plugin.settings.autoPushInterval + ); + } + this.display(); + }) + ); + new import_obsidian8.Setting(containerEl).setName(`Vault ${commitOrBackup} interval (minutes)`).setDesc( + `${plugin.settings.differentIntervalCommitAndPush ? "Commit" : "Commit and push"} changes every X minutes. Set to 0 (default) to disable. (See below setting for further configuration!)` + ).addText( + (text2) => text2.setValue(String(plugin.settings.autoSaveInterval)).onChange((value) => { + if (!isNaN(Number(value))) { + plugin.settings.autoSaveInterval = Number(value); + plugin.saveSettings(); + if (plugin.settings.autoSaveInterval > 0) { + plugin.clearAutoBackup(); + plugin.startAutoBackup( + plugin.settings.autoSaveInterval + ); + new import_obsidian8.Notice( + `Automatic ${commitOrBackup} enabled! Every ${plugin.settings.autoSaveInterval} minutes.` + ); + } else if (plugin.settings.autoSaveInterval <= 0) { + plugin.clearAutoBackup() && new import_obsidian8.Notice( + `Automatic ${commitOrBackup} disabled!` + ); + } + } else { + new import_obsidian8.Notice("Please specify a valid number."); + } + }) + ); + if (!plugin.settings.setLastSaveToLastCommit) + new import_obsidian8.Setting(containerEl).setName(`Auto Backup after file change`).setDesc( + `If turned on, do auto ${commitOrBackup} every ${plugin.settings.autoSaveInterval} minutes after last change. This also prevents auto ${commitOrBackup} while editing a file. If turned off, it's independent from the last change.` + ).addToggle( + (toggle) => toggle.setValue(plugin.settings.autoBackupAfterFileChange).onChange((value) => { + plugin.settings.autoBackupAfterFileChange = value; + this.display(); + plugin.saveSettings(); + plugin.clearAutoBackup(); + if (plugin.settings.autoSaveInterval > 0) { + plugin.startAutoBackup( + plugin.settings.autoSaveInterval + ); + } + }) + ); + if (!plugin.settings.autoBackupAfterFileChange) + new import_obsidian8.Setting(containerEl).setName(`Auto ${commitOrBackup} after latest commit`).setDesc( + `If turned on, set last auto ${commitOrBackup} time to latest commit` + ).addToggle( + (toggle) => toggle.setValue(plugin.settings.setLastSaveToLastCommit).onChange(async (value) => { + plugin.settings.setLastSaveToLastCommit = value; + plugin.saveSettings(); + this.display(); + plugin.clearAutoBackup(); + await plugin.setUpAutoBackup(); + }) + ); + if (plugin.settings.differentIntervalCommitAndPush) { + new import_obsidian8.Setting(containerEl).setName(`Vault push interval (minutes)`).setDesc( + "Push changes every X minutes. Set to 0 (default) to disable." + ).addText( + (text2) => text2.setValue(String(plugin.settings.autoPushInterval)).onChange((value) => { + if (!isNaN(Number(value))) { + plugin.settings.autoPushInterval = Number(value); + plugin.saveSettings(); + if (plugin.settings.autoPushInterval > 0) { + plugin.clearAutoPush(); + plugin.startAutoPush( + plugin.settings.autoPushInterval + ); + new import_obsidian8.Notice( + `Automatic push enabled! Every ${plugin.settings.autoPushInterval} minutes.` + ); + } else if (plugin.settings.autoPushInterval <= 0) { + plugin.clearAutoPush() && new import_obsidian8.Notice( + "Automatic push disabled!" + ); + } + } else { + new import_obsidian8.Notice( + "Please specify a valid number." + ); + } + }) + ); + } + new import_obsidian8.Setting(containerEl).setName("Auto pull interval (minutes)").setDesc( + "Pull changes every X minutes. Set to 0 (default) to disable." + ).addText( + (text2) => text2.setValue(String(plugin.settings.autoPullInterval)).onChange((value) => { + if (!isNaN(Number(value))) { + plugin.settings.autoPullInterval = Number(value); + plugin.saveSettings(); + if (plugin.settings.autoPullInterval > 0) { + plugin.clearAutoPull(); + plugin.startAutoPull( + plugin.settings.autoPullInterval + ); + new import_obsidian8.Notice( + `Automatic pull enabled! Every ${plugin.settings.autoPullInterval} minutes.` + ); + } else if (plugin.settings.autoPullInterval <= 0) { + plugin.clearAutoPull() && new import_obsidian8.Notice("Automatic pull disabled!"); + } + } else { + new import_obsidian8.Notice("Please specify a valid number."); + } + }) + ); + new import_obsidian8.Setting(containerEl).setName("Specify custom commit message on auto backup").setDesc("You will get a pop up to specify your message").addToggle( + (toggle) => toggle.setValue(plugin.settings.customMessageOnAutoBackup).onChange((value) => { + plugin.settings.customMessageOnAutoBackup = value; + plugin.saveSettings(); + }) + ); + new import_obsidian8.Setting(containerEl).setName("Commit message on auto backup/commit").setDesc( + "Available placeholders: {{date}} (see below), {{hostname}} (see below), {{numFiles}} (number of changed files in the commit) and {{files}} (changed files in commit message)" + ).addTextArea( + (text2) => text2.setPlaceholder("vault backup: {{date}}").setValue(plugin.settings.autoCommitMessage).onChange((value) => { + plugin.settings.autoCommitMessage = value; + plugin.saveSettings(); + }) + ); + containerEl.createEl("br"); + containerEl.createEl("h3", { text: "Commit message" }); + new import_obsidian8.Setting(containerEl).setName("Commit message on manual backup/commit").setDesc( + "Available placeholders: {{date}} (see below), {{hostname}} (see below), {{numFiles}} (number of changed files in the commit) and {{files}} (changed files in commit message)" + ).addTextArea( + (text2) => text2.setPlaceholder("vault backup: {{date}}").setValue( + plugin.settings.commitMessage ? plugin.settings.commitMessage : "" + ).onChange((value) => { + plugin.settings.commitMessage = value; + plugin.saveSettings(); + }) + ); + new import_obsidian8.Setting(containerEl).setName("{{date}} placeholder format").setDesc( + `Specify custom date format. E.g. "${DATE_TIME_FORMAT_SECONDS}"` + ).addText( + (text2) => text2.setPlaceholder(plugin.settings.commitDateFormat).setValue(plugin.settings.commitDateFormat).onChange(async (value) => { + plugin.settings.commitDateFormat = value; + await plugin.saveSettings(); + }) + ); + new import_obsidian8.Setting(containerEl).setName("{{hostname}} placeholder replacement").setDesc("Specify custom hostname for every device.").addText( + (text2) => { + var _a2; + return text2.setValue((_a2 = plugin.localStorage.getHostname()) != null ? _a2 : "").onChange(async (value) => { + plugin.localStorage.setHostname(value); + }); + } + ); + new import_obsidian8.Setting(containerEl).setName("Preview commit message").addButton( + (button) => button.setButtonText("Preview").onClick(async () => { + const commitMessagePreview = await plugin.gitManager.formatCommitMessage( + plugin.settings.commitMessage + ); + new import_obsidian8.Notice(`${commitMessagePreview}`); + }) + ); + new import_obsidian8.Setting(containerEl).setName("List filenames affected by commit in the commit body").addToggle( + (toggle) => toggle.setValue(plugin.settings.listChangedFilesInMessageBody).onChange((value) => { + plugin.settings.listChangedFilesInMessageBody = value; + plugin.saveSettings(); + }) + ); + containerEl.createEl("br"); + containerEl.createEl("h3", { text: "Backup" }); + if (plugin.gitManager instanceof SimpleGit) + new import_obsidian8.Setting(containerEl).setName("Sync Method").setDesc( + "Selects the method used for handling new changes found in your remote git repository." + ).addDropdown((dropdown) => { + const options = { + merge: "Merge", + rebase: "Rebase", + reset: "Other sync service (Only updates the HEAD without touching the working directory)" + }; + dropdown.addOptions(options); + dropdown.setValue(plugin.settings.syncMethod); + dropdown.onChange(async (option) => { + plugin.settings.syncMethod = option; + plugin.saveSettings(); + }); + }); + new import_obsidian8.Setting(containerEl).setName("Pull updates on startup").setDesc("Automatically pull updates when Obsidian starts").addToggle( + (toggle) => toggle.setValue(plugin.settings.autoPullOnBoot).onChange((value) => { + plugin.settings.autoPullOnBoot = value; + plugin.saveSettings(); + }) + ); + new import_obsidian8.Setting(containerEl).setName("Push on backup").setDesc("Disable to only commit changes").addToggle( + (toggle) => toggle.setValue(!plugin.settings.disablePush).onChange((value) => { + plugin.settings.disablePush = !value; + plugin.saveSettings(); + }) + ); + new import_obsidian8.Setting(containerEl).setName("Pull changes before push").setDesc("Commit -> pull -> push (Only if pushing is enabled)").addToggle( + (toggle) => toggle.setValue(plugin.settings.pullBeforePush).onChange((value) => { + plugin.settings.pullBeforePush = value; + plugin.saveSettings(); + }) + ); + if (plugin.gitManager instanceof SimpleGit) { + containerEl.createEl("br"); + containerEl.createEl("h3", { text: "Line author information" }); + this.addLineAuthorInfoSettings(); + } + } + containerEl.createEl("br"); + containerEl.createEl("h3", { text: "Miscellaneous" }); + new import_obsidian8.Setting(containerEl).setName( + "Automatically refresh Source Control View on file changes" + ).setDesc( + "On slower machines this may cause lags. If so, just disable this option" + ).addToggle( + (toggle) => toggle.setValue(plugin.settings.refreshSourceControl).onChange((value) => { + plugin.settings.refreshSourceControl = value; + plugin.saveSettings(); + }) + ); + new import_obsidian8.Setting(containerEl).setName("Source Control View refresh interval").setDesc( + "Milliseconds to wait after file change before refreshing the Source Control View" + ).addText( + (toggle) => toggle.setValue( + plugin.settings.refreshSourceControlTimer.toString() + ).setPlaceholder("7000").onChange((value) => { + plugin.settings.refreshSourceControlTimer = Math.max( + parseInt(value), + 500 + ); + plugin.saveSettings(); + plugin.setRefreshDebouncer(); + }) + ); + new import_obsidian8.Setting(containerEl).setName("Disable notifications").setDesc( + "Disable notifications for git operations to minimize distraction (refer to status bar for updates). Errors are still shown as notifications even if you enable this setting" + ).addToggle( + (toggle) => toggle.setValue(plugin.settings.disablePopups).onChange((value) => { + plugin.settings.disablePopups = value; + plugin.saveSettings(); + }) + ); + new import_obsidian8.Setting(containerEl).setName("Show status bar").setDesc( + "Obsidian must be restarted for the changes to take affect" + ).addToggle( + (toggle) => toggle.setValue(plugin.settings.showStatusBar).onChange((value) => { + plugin.settings.showStatusBar = value; + plugin.saveSettings(); + }) + ); + new import_obsidian8.Setting(containerEl).setName("Show stage/unstage button in file menu").addToggle( + (toggle) => toggle.setValue(plugin.settings.showFileMenu).onChange((value) => { + plugin.settings.showFileMenu = value; + plugin.saveSettings(); + }) + ); + new import_obsidian8.Setting(containerEl).setName("Show branch status bar").setDesc( + "Obsidian must be restarted for the changes to take affect" + ).addToggle( + (toggle) => toggle.setValue(plugin.settings.showBranchStatusBar).onChange((value) => { + plugin.settings.showBranchStatusBar = value; + plugin.saveSettings(); + }) + ); + new import_obsidian8.Setting(containerEl).setName("Show changes files count in status bar").addToggle( + (toggle) => toggle.setValue(plugin.settings.changedFilesInStatusBar).onChange((value) => { + plugin.settings.changedFilesInStatusBar = value; + plugin.saveSettings(); + }) + ); + containerEl.createEl("br"); + if (plugin.gitManager instanceof IsomorphicGit) { + containerEl.createEl("h3", { + text: "Authentication/Commit Author" + }); + } else { + containerEl.createEl("h3", { text: "Commit Author" }); + } + if (plugin.gitManager instanceof IsomorphicGit) + new import_obsidian8.Setting(containerEl).setName( + "Username on your git server. E.g. your username on GitHub" + ).addText((cb) => { + var _a2; + cb.setValue((_a2 = plugin.localStorage.getUsername()) != null ? _a2 : ""); + cb.onChange((value) => { + plugin.localStorage.setUsername(value); + }); + }); + if (plugin.gitManager instanceof IsomorphicGit) + new import_obsidian8.Setting(containerEl).setName("Password/Personal access token").setDesc( + "Type in your password. You won't be able to see it again." + ).addText((cb) => { + cb.inputEl.autocapitalize = "off"; + cb.inputEl.autocomplete = "off"; + cb.inputEl.spellcheck = false; + cb.onChange((value) => { + plugin.localStorage.setPassword(value); + }); + }); + if (plugin.gitReady) + new import_obsidian8.Setting(containerEl).setName("Author name for commit").addText(async (cb) => { + cb.setValue(await plugin.gitManager.getConfig("user.name")); + cb.onChange((value) => { + plugin.gitManager.setConfig( + "user.name", + value == "" ? void 0 : value + ); + }); + }); + if (plugin.gitReady) + new import_obsidian8.Setting(containerEl).setName("Author email for commit").addText(async (cb) => { + cb.setValue( + await plugin.gitManager.getConfig("user.email") + ); + cb.onChange((value) => { + plugin.gitManager.setConfig( + "user.email", + value == "" ? void 0 : value + ); + }); + }); + containerEl.createEl("br"); + containerEl.createEl("h3", { text: "Advanced" }); + if (plugin.gitManager instanceof SimpleGit) { + new import_obsidian8.Setting(containerEl).setName("Update submodules").setDesc( + '"Create backup" and "pull" takes care of submodules. Missing features: Conflicted files, count of pulled/pushed/committed files. Tracking branch needs to be set for each submodule' + ).addToggle( + (toggle) => toggle.setValue(plugin.settings.updateSubmodules).onChange((value) => { + plugin.settings.updateSubmodules = value; + plugin.saveSettings(); + }) + ); + if (plugin.settings.updateSubmodules) { + new import_obsidian8.Setting(containerEl).setName("Submodule recurse checkout/switch").setDesc( + "Whenever a checkout happens on the root repository, recurse the checkout on the submodules (if the branches exist)." + ).addToggle( + (toggle) => toggle.setValue(plugin.settings.submoduleRecurseCheckout).onChange((value) => { + plugin.settings.submoduleRecurseCheckout = value; + plugin.saveSettings(); + }) + ); + } + } + if (plugin.gitManager instanceof SimpleGit) + new import_obsidian8.Setting(containerEl).setName("Custom Git binary path").addText((cb) => { + var _a2; + cb.setValue((_a2 = plugin.localStorage.getGitPath()) != null ? _a2 : ""); + cb.setPlaceholder("git"); + cb.onChange((value) => { + plugin.localStorage.setGitPath(value); + plugin.gitManager.updateGitPath(value || "git"); + }); + }); + if (plugin.gitManager instanceof SimpleGit) + new import_obsidian8.Setting(containerEl).setName("Additional environment variables").setDesc( + "Use each line for a new environment variable in the format KEY=VALUE" + ).addTextArea((cb) => { + cb.setPlaceholder("GIT_DIR=/path/to/git/dir"); + cb.setValue(plugin.localStorage.getEnvVars().join("\n")); + cb.onChange((value) => { + plugin.localStorage.setEnvVars(value.split("\n")); + }); + }); + if (plugin.gitManager instanceof SimpleGit) + new import_obsidian8.Setting(containerEl).setName("Additional PATH environment variable paths").setDesc("Use each line for one path").addTextArea((cb) => { + cb.setValue(plugin.localStorage.getPATHPaths().join("\n")); + cb.onChange((value) => { + plugin.localStorage.setPATHPaths(value.split("\n")); + }); + }); + if (plugin.gitManager instanceof SimpleGit) + new import_obsidian8.Setting(containerEl).setName("Reload with new environment variables").setDesc( + "Removing previously added environment variables will not take effect until Obsidian is restarted." + ).addButton((cb) => { + cb.setButtonText("Reload"); + cb.setCta(); + cb.onClick(() => { + plugin.gitManager.setGitInstance(); + }); + }); + new import_obsidian8.Setting(containerEl).setName("Custom base path (Git repository path)").setDesc( + ` + Sets the relative path to the vault from which the Git binary should be executed. + Mostly used to set the path to the Git repository, which is only required if the Git repository is below the vault root directory. Use "\\" instead of "/" on Windows. + ` + ).addText((cb) => { + cb.setValue(plugin.settings.basePath); + cb.setPlaceholder("directory/directory-with-git-repo"); + cb.onChange((value) => { + plugin.settings.basePath = value; + plugin.saveSettings(); + plugin.gitManager.updateBasePath(value || ""); + }); + }); + new import_obsidian8.Setting(containerEl).setName("Custom Git directory path (Instead of '.git')").setDesc( + `Requires restart of Obsidian to take effect. Use "\\" instead of "/" on Windows.` + ).addText((cb) => { + cb.setValue(plugin.settings.gitDir); + cb.setPlaceholder(".git"); + cb.onChange((value) => { + plugin.settings.gitDir = value; + plugin.saveSettings(); + }); + }); + new import_obsidian8.Setting(containerEl).setName("Disable on this device").addToggle( + (toggle) => toggle.setValue(plugin.localStorage.getPluginDisabled()).onChange((value) => { + plugin.localStorage.setPluginDisabled(value); + if (value) { + plugin.unloadPlugin(); + } else { + plugin.loadPlugin(); + } + new import_obsidian8.Notice( + "Obsidian must be restarted for the changes to take affect" + ); + }) + ); + new import_obsidian8.Setting(containerEl).setName("Donate").setDesc( + "If you like this Plugin, consider donating to support continued development." + ).addButton((bt) => { + bt.buttonEl.outerHTML = "Buy Me a Coffee at ko-fi.com"; + }); + const info = containerEl.createDiv(); + info.setAttr("align", "center"); + info.setText( + "Debugging and logging:\nYou can always see the logs of this and every other plugin by opening the console with" + ); + const keys = containerEl.createDiv(); + keys.setAttr("align", "center"); + keys.addClass("obsidian-git-shortcuts"); + if (import_obsidian8.Platform.isMacOS === true) { + keys.createEl("kbd", { text: "CMD (\u2318) + OPTION (\u2325) + I" }); + } else { + keys.createEl("kbd", { text: "CTRL + SHIFT + I" }); + } + } + configureLineAuthorShowStatus(show) { + this.settings.lineAuthor.show = show; + this.plugin.saveSettings(); + if (show) + this.plugin.lineAuthoringFeature.activateFeature(); + else + this.plugin.lineAuthoringFeature.deactivateFeature(); + } + /** + * Persists the setting {@link key} with value {@link value} and + * refreshes the line author info views. + */ + lineAuthorSettingHandler(key2, value) { + this.settings.lineAuthor[key2] = value; + this.plugin.saveSettings(); + this.plugin.lineAuthoringFeature.refreshLineAuthorViews(); + } + /** + * Ensure, that certain last shown values are persisten in the settings. + * + * Necessary for the line author info gutter context menus. + */ + beforeSaveSettings() { + const laSettings = this.settings.lineAuthor; + if (laSettings.authorDisplay !== "hide") { + laSettings.lastShownAuthorDisplay = laSettings.authorDisplay; + } + if (laSettings.dateTimeFormatOptions !== "hide") { + laSettings.lastShownDateTimeFormatOptions = laSettings.dateTimeFormatOptions; + } + } + addLineAuthorInfoSettings() { + const baseLineAuthorInfoSetting = new import_obsidian8.Setting(this.containerEl).setName( + "Show commit authoring information next to each line" + ); + if (!this.plugin.lineAuthoringFeature.isAvailableOnCurrentPlatform()) { + baseLineAuthorInfoSetting.setDesc("Only available on desktop currently.").setDisabled(true); + } + baseLineAuthorInfoSetting.descEl.innerHTML = ` + Feature guide and quick examples
+ The commit hash, author name and authoring date can all be individually toggled.
Hide everything, to only show the age-colored sidebar.`; + baseLineAuthorInfoSetting.addToggle( + (toggle) => toggle.setValue(this.settings.lineAuthor.show).onChange((value) => { + this.configureLineAuthorShowStatus(value); + this.display(); + }) + ); + if (this.settings.lineAuthor.show) { + const trackMovement = new import_obsidian8.Setting(this.containerEl).setName("Follow movement and copies across files and commits").setDesc("").addDropdown((dropdown) => { + dropdown.addOptions({ + inactive: "Do not follow (default)", + "same-commit": "Follow within same commit", + "all-commits": "Follow within all commits (maybe slow)" + }); + dropdown.setValue(this.settings.lineAuthor.followMovement); + dropdown.onChange( + (value) => this.lineAuthorSettingHandler("followMovement", value) + ); + }); + trackMovement.descEl.innerHTML = ` + By default (deactivated), each line only shows the newest commit where it was changed. +
+ With same commit, cut-copy-paste-ing of text is followed within the same commit and the original commit of authoring will be shown. +
+ With all commits, cut-copy-paste-ing text inbetween multiple commits will be detected. +
+ It uses git-blame and + for matches (at least ${GIT_LINE_AUTHORING_MOVEMENT_DETECTION_MINIMAL_LENGTH} characters) within the same (or all) commit(s), the originating commit's information is shown.`; + new import_obsidian8.Setting(this.containerEl).setName("Show commit hash").addToggle((tgl) => { + tgl.setValue(this.settings.lineAuthor.showCommitHash); + tgl.onChange( + async (value) => this.lineAuthorSettingHandler("showCommitHash", value) + ); + }); + new import_obsidian8.Setting(this.containerEl).setName("Author name display").setDesc("If and how the author is displayed").addDropdown((dropdown) => { + const options = { + hide: "Hide", + initials: "Initials (default)", + "first name": "First name", + "last name": "Last name", + full: "Full name" + }; + dropdown.addOptions(options); + dropdown.setValue(this.settings.lineAuthor.authorDisplay); + dropdown.onChange( + async (value) => this.lineAuthorSettingHandler("authorDisplay", value) + ); + }); + new import_obsidian8.Setting(this.containerEl).setName("Authoring date display").setDesc( + "If and how the date and time of authoring the line is displayed" + ).addDropdown((dropdown) => { + const options = { + hide: "Hide", + date: "Date (default)", + datetime: "Date and time", + "natural language": "Natural language", + custom: "Custom" + }; + dropdown.addOptions(options); + dropdown.setValue( + this.settings.lineAuthor.dateTimeFormatOptions + ); + dropdown.onChange( + async (value) => { + this.lineAuthorSettingHandler( + "dateTimeFormatOptions", + value + ); + this.display(); + } + ); + }); + if (this.settings.lineAuthor.dateTimeFormatOptions === "custom") { + const dateTimeFormatCustomStringSetting = new import_obsidian8.Setting( + this.containerEl + ); + dateTimeFormatCustomStringSetting.setName("Custom authoring date format").addText((cb) => { + cb.setValue( + this.settings.lineAuthor.dateTimeFormatCustomString + ); + cb.setPlaceholder("YYYY-MM-DD HH:mm"); + cb.onChange((value) => { + this.lineAuthorSettingHandler( + "dateTimeFormatCustomString", + value + ); + dateTimeFormatCustomStringSetting.descEl.innerHTML = this.previewCustomDateTimeDescriptionHtml( + value + ); + }); + }); + dateTimeFormatCustomStringSetting.descEl.innerHTML = this.previewCustomDateTimeDescriptionHtml( + this.settings.lineAuthor.dateTimeFormatCustomString + ); + } + new import_obsidian8.Setting(this.containerEl).setName("Authoring date display timezone").addDropdown((dropdown) => { + const options = { + "viewer-local": "My local (default)", + "author-local": "Author's local", + utc0000: "UTC+0000/Z" + }; + dropdown.addOptions(options); + dropdown.setValue( + this.settings.lineAuthor.dateTimeTimezone + ); + dropdown.onChange( + async (value) => this.lineAuthorSettingHandler("dateTimeTimezone", value) + ); + }).descEl.innerHTML = ` + The time-zone in which the authoring date should be shown. + Either your local time-zone (default), + the author's time-zone during commit creation or + UTC\xB100:00. + `; + const oldestAgeSetting = new import_obsidian8.Setting(this.containerEl).setName( + "Oldest age in coloring" + ); + oldestAgeSetting.descEl.innerHTML = this.previewOldestAgeDescriptionHtml( + this.settings.lineAuthor.coloringMaxAge + )[0]; + oldestAgeSetting.addText((text2) => { + text2.setPlaceholder("1y"); + text2.setValue(this.settings.lineAuthor.coloringMaxAge); + text2.onChange((value) => { + const [preview, valid] = this.previewOldestAgeDescriptionHtml(value); + oldestAgeSetting.descEl.innerHTML = preview; + if (valid) { + this.lineAuthorSettingHandler("coloringMaxAge", value); + this.refreshColorSettingsName("oldest"); + } + }); + }); + this.createColorSetting("newest"); + this.createColorSetting("oldest"); + new import_obsidian8.Setting(this.containerEl).setName("Text color").addText((field) => { + field.setValue(this.settings.lineAuthor.textColorCss); + field.onChange((value) => { + this.lineAuthorSettingHandler("textColorCss", value); + }); + }).descEl.innerHTML = ` + The CSS color of the gutter text.
+ + It is higly recommended to use + + CSS variables + defined by themes + (e.g. 
var(--text-muted)
or + 
var(--text-on-accent)
, + because they automatically adapt to theme changes.
+ + See: + List of available CSS variables in Obsidian + + `; + new import_obsidian8.Setting(this.containerEl).setName("Ignore whitespace and newlines in changes").addToggle((tgl) => { + tgl.setValue(this.settings.lineAuthor.ignoreWhitespace); + tgl.onChange( + (value) => this.lineAuthorSettingHandler("ignoreWhitespace", value) + ); + }).descEl.innerHTML = ` + Whitespace and newlines are interpreted as + part of the document and in changes + by default (hence not ignored). + This makes the last line being shown as 'changed' + when a new subsequent line is added, + even if the previously last line's text is the same. +
+ If you don't care about purely-whitespace changes + (e.g. list nesting / quote indentation changes), + then activating this will provide more meaningful change detection. + `; + } + } + createColorSetting(which) { + const setting = new import_obsidian8.Setting(this.containerEl).setName("").addText((text2) => { + const color = pickColor(which, this.settings.lineAuthor); + const defaultColor = pickColor( + which, + DEFAULT_SETTINGS.lineAuthor + ); + text2.setPlaceholder(rgbToString(defaultColor)); + text2.setValue(rgbToString(color)); + text2.onChange((colorNew) => { + const rgb = convertToRgb(colorNew); + if (rgb !== void 0) { + const key2 = which === "newest" ? "colorNew" : "colorOld"; + this.lineAuthorSettingHandler(key2, rgb); + } + this.refreshColorSettingsDesc(which, rgb); + }); + }); + this.lineAuthorColorSettings.set(which, setting); + this.refreshColorSettingsName(which); + this.refreshColorSettingsDesc( + which, + pickColor(which, this.settings.lineAuthor) + ); + } + refreshColorSettingsName(which) { + const settingsDom = this.lineAuthorColorSettings.get(which); + if (settingsDom) { + const whichDescriber = which === "oldest" ? `oldest (${this.settings.lineAuthor.coloringMaxAge} or older)` : "newest"; + settingsDom.nameEl.innerText = `Color for ${whichDescriber} commits`; + } + } + refreshColorSettingsDesc(which, rgb) { + const settingsDom = this.lineAuthorColorSettings.get(which); + if (settingsDom) { + settingsDom.descEl.innerHTML = this.colorSettingPreviewDescHtml( + which, + this.settings.lineAuthor, + rgb !== void 0 + ); + } + } + colorSettingPreviewDescHtml(which, laSettings, colorIsValid) { + const rgbStr = colorIsValid ? previewColor(which, laSettings) : `rgba(127,127,127,0.3)`; + const today = import_obsidian8.moment.unix(import_obsidian8.moment.now() / 1e3).format("YYYY-MM-DD"); + const text2 = colorIsValid ? `abcdef Author Name ${today}` : "invalid color"; + const preview = `
${text2}
`; + return `Supports 'rgb(r,g,b)', 'hsl(h,s,l)', hex (#) and + named colors (e.g. 'black', 'purple'). Color preview: ${preview}`; + } + previewCustomDateTimeDescriptionHtml(dateTimeFormatCustomString) { + const formattedDateTime = (0, import_obsidian8.moment)().format(dateTimeFormatCustomString); + return `Format string to display the authoring date.
Currently: ${formattedDateTime}`; + } + previewOldestAgeDescriptionHtml(coloringMaxAge) { + const duration = parseColoringMaxAgeDuration(coloringMaxAge); + const durationString = duration !== void 0 ? `${duration.asDays()} days` : "invalid!"; + return [ + `The oldest age in the line author coloring. Everything older will have the same color. +
Smallest valid age is "1d". Currently: ${durationString}`, + duration + ]; + } +}; +function pickColor(which, las) { + return which === "oldest" ? las.colorOld : las.colorNew; +} +function parseColoringMaxAgeDuration(durationString) { + const duration = import_obsidian8.moment.duration("P" + durationString.toUpperCase()); + return duration.isValid() && duration.asDays() && duration.asDays() >= 1 ? duration : void 0; +} + +// src/lineAuthor/model.ts +function lineAuthoringId(head, objHash, path2) { + if (head === void 0 || objHash === void 0 || path2 === void 0) { + return void 0; + } + return `head${head}-obj${objHash}-path${path2}`; +} +var LineAuthoringContainerType = import_state.Annotation.define(); +function newComputationResultAsTransaction(key2, la, state) { + return state.update({ + annotations: LineAuthoringContainerType.of({ + key: key2, + la, + lineOffsetsFromUnsavedChanges: /* @__PURE__ */ new Map() + }) + }); +} +function getLineAuthorAnnotation(tr) { + return tr.annotation(LineAuthoringContainerType); +} +var lineAuthorState = import_state.StateField.define({ + create: (_state) => void 0, + /** + * The state can be updated from either an annotated transaction containing + * the newest line authoring (for the saved document) - or from + * unsaved changes of the document as the user is actively typing in the editor. + * + * In the first case, we take the new line authoring and discard anything we had remembered + * from unsaved changes. In the second case, we use the unsaved changes in {@link enrichUnsavedChanges} to pre-compute information to immediately update the + * line author gutter without needing to wait until the document is saved and the + * line authoring is properly computed. + */ + update: (previous, transaction) => { + var _a2; + return (_a2 = getLineAuthorAnnotation(transaction)) != null ? _a2 : enrichUnsavedChanges(transaction, previous); + }, + // compare cache keys. + // equality rate is >= 95% :) + // hence avoids recomputation of views + compare: (l, r) => (l == null ? void 0 : l.key) === (r == null ? void 0 : r.key) +}); +function laStateDigest(laState) { + var _a2; + const digest = import_js_sha256.sha256.create(); + if (!laState) + return digest; + const { la, key: key2, lineOffsetsFromUnsavedChanges } = laState; + digest.update(la === "untracked" ? "t" : "f"); + digest.update(key2); + for (const [k, v] of (_a2 = lineOffsetsFromUnsavedChanges.entries()) != null ? _a2 : []) + digest.update([k, v]); + return digest; +} +var latestSettings = { + get: void 0, + save: void 0 +}; +function provideSettingsAccess(settingsGetter, settingsSetter) { + latestSettings.get = settingsGetter; + latestSettings.save = settingsSetter; +} +function maxAgeInDaysFromSettings(settings) { + var _a2, _b; + return (_b = (_a2 = parseColoringMaxAgeDuration(settings.coloringMaxAge)) == null ? void 0 : _a2.asDays()) != null ? _b : parseColoringMaxAgeDuration( + DEFAULT_SETTINGS.lineAuthor.coloringMaxAge + ).asDays(); +} +function enrichUnsavedChanges(tr, prev) { + if (!prev) + return void 0; + if (!tr.changes.empty) { + tr.changes.iterChanges((fromA, toA, fromB, toB) => { + var _a2; + const oldDoc = tr.startState.doc; + const { newDoc } = tr; + const beforeFrom = oldDoc.lineAt(fromA).number; + const beforeTo = oldDoc.lineAt(toA).number; + const afterFrom = newDoc.lineAt(fromB).number; + const afterTo = newDoc.lineAt(toB).number; + const beforeLen = beforeTo - beforeFrom + 1; + const afterLen = afterTo - afterFrom + 1; + for (let afterI = afterFrom; afterI <= afterTo; afterI++) { + let offset = (_a2 = prev.lineOffsetsFromUnsavedChanges.get(afterI)) != null ? _a2 : 0; + const isLastLine = afterTo === afterI; + const changeInNumberOfLines = afterLen - beforeLen; + if (isLastLine) + offset += changeInNumberOfLines; + prev.lineOffsetsFromUnsavedChanges.set(afterI, offset); + } + }); + } + return prev; +} + +// src/lineAuthor/control.ts +var LineAuthoringSubscriber = class { + // remember path to detect and adapt to renames + constructor(state) { + this.state = state; + this.subscribeMe(); + } + async notifyLineAuthoring(id, la) { + if (this.view === void 0) { + console.warn( + `Obsidian Git: View is not defined for editor cache key. Unforeseen situation. id: ${id}` + ); + return; + } + const state = this.view.state; + const transaction = newComputationResultAsTransaction(id, la, state); + this.view.dispatch(transaction); + } + updateToNewState(state) { + const filepathChanged = this.lastSeenPath && this.filepath != this.lastSeenPath; + this.state = state; + if (filepathChanged) { + this.unsubscribeMe(this.lastSeenPath); + this.subscribeMe(); + } + return this; + } + removeIfStale() { + if (this.view.destroyed) { + this.unsubscribeMe(this.lastSeenPath); + } + } + subscribeMe() { + if (this.filepath === void 0) + return; + eventsPerFilePathSingleton.ifFilepathDefinedTransformSubscribers( + this.filepath, + (subs) => subs.add(this) + ); + this.lastSeenPath = this.filepath; + } + unsubscribeMe(oldFilepath) { + eventsPerFilePathSingleton.ifFilepathDefinedTransformSubscribers( + oldFilepath, + (subs) => subs.delete(this) + ); + } + get filepath() { + var _a2, _b; + return (_b = (_a2 = this.state.field(import_obsidian9.editorViewField)) == null ? void 0 : _a2.file) == null ? void 0 : _b.path; + } + get view() { + return this.state.field(import_obsidian9.editorEditorField); + } +}; +var subscribeNewEditor = import_state2.StateField.define({ + create: (state) => new LineAuthoringSubscriber(state), + update: (v, transaction) => v.updateToNewState(transaction.state), + compare: (a, b) => a === b +}); + +// src/lineAuthor/view/cache.ts +init_polyfill_buffer(); +function clearViewCache() { + longestRenderedGutter = void 0; + renderedAgeInDaysForAdaptiveInitialColoring = []; + ageIdx = 0; + gutterInstances.clear(); + gutterMarkersRangeSet.clear(); + attachedGutterElements.clear(); +} +var longestRenderedGutter = void 0; +var getLongestRenderedGutter = () => longestRenderedGutter; +function conditionallyUpdateLongestRenderedGutter(gutter2, text2) { + var _a2; + const length = text2.length; + if (length < ((_a2 = longestRenderedGutter == null ? void 0 : longestRenderedGutter.length) != null ? _a2 : 0)) + return; + longestRenderedGutter = { gutter: gutter2, length, text: text2 }; + const settings = latestSettings.get(); + if (length !== settings.gutterSpacingFallbackLength) { + settings.gutterSpacingFallbackLength = length; + latestSettings.save(settings); + } +} +var renderedAgeInDaysForAdaptiveInitialColoring = []; +var ADAPTIVE_INITIAL_COLORING_AGE_CACHE_SIZE = 15; +var ageIdx = 0; +function recordRenderedAgeInDays(age) { + renderedAgeInDaysForAdaptiveInitialColoring[ageIdx] = age; + ageIdx = (ageIdx + 1) % ADAPTIVE_INITIAL_COLORING_AGE_CACHE_SIZE; +} +function computeAdaptiveInitialColoringAgeInDays() { + return median(renderedAgeInDaysForAdaptiveInitialColoring); +} +var gutterInstances = /* @__PURE__ */ new Map(); +var gutterMarkersRangeSet = /* @__PURE__ */ new Map(); +var attachedGutterElements = /* @__PURE__ */ new Set(); + +// src/lineAuthor/view/view.ts +init_polyfill_buffer(); +var import_state3 = require("@codemirror/state"); +var import_view2 = require("@codemirror/view"); + +// src/lineAuthor/view/gutter/gutter.ts +init_polyfill_buffer(); +var import_view = require("@codemirror/view"); +var import_js_sha2562 = __toESM(require_sha256()); +var import_obsidian10 = require("obsidian"); + +// src/lineAuthor/view/contextMenu.ts +init_polyfill_buffer(); + +// src/lineAuthor/view/gutter/gutterElementSearch.ts +init_polyfill_buffer(); +var mouseXY = { x: -10, y: -10 }; +function prepareGutterSearchForContextMenuHandling() { + if (mouseXY.x === -10) { + window.addEventListener("mousedown", (e) => { + mouseXY.x = e.clientX; + mouseXY.y = e.clientY; + }); + } +} +function findGutterElementUnderMouse() { + for (const elt of attachedGutterElements) { + if (contains(elt, mouseXY)) + return elt; + } +} +function contains(elt, pt) { + const { x, y, width, height } = elt.getBoundingClientRect(); + return x <= pt.x && pt.x <= x + width && y <= pt.y && pt.y <= y + height; +} + +// src/pluginGlobalRef.ts +init_polyfill_buffer(); +var pluginRef = {}; + +// src/lineAuthor/view/contextMenu.ts +var COMMIT_ATTR = "data-commit"; +function handleContextMenu(menu, editor, _mdv) { + if (editor.hasFocus()) + return; + const gutterElement = findGutterElementUnderMouse(); + if (!gutterElement) + return; + const info = getCommitInfo(gutterElement); + if (!info) + return; + if (!info.isZeroCommit && !info.isWaitingGutter) { + addCopyHashMenuItem(info, menu); + } + addConfigurableLineAuthorSettings("showCommitHash", menu); + addConfigurableLineAuthorSettings("authorDisplay", menu); + addConfigurableLineAuthorSettings("dateTimeFormatOptions", menu); +} +function addCopyHashMenuItem(commit2, menu) { + menu.addItem( + (item) => item.setTitle("Copy commit hash").setIcon("copy").setSection("obs-git-line-author-copy").onClick((_e) => navigator.clipboard.writeText(commit2.hash)) + ); +} +function addConfigurableLineAuthorSettings(key2, menu) { + var _a2, _b; + let title; + let actionNewValue; + const settings = pluginRef.plugin.settings.lineAuthor; + const currentValue = settings[key2]; + const currentlyShown = typeof currentValue === "boolean" ? currentValue : currentValue !== "hide"; + const defaultValue = DEFAULT_SETTINGS.lineAuthor[key2]; + if (key2 === "showCommitHash") { + title = "Show commit hash"; + actionNewValue = !currentValue; + } else if (key2 === "authorDisplay") { + const showOption = (_a2 = settings.lastShownAuthorDisplay) != null ? _a2 : defaultValue; + title = "Show author " + (currentlyShown ? currentValue : showOption); + actionNewValue = currentlyShown ? "hide" : showOption; + } else if (key2 === "dateTimeFormatOptions") { + const showOption = (_b = settings.lastShownDateTimeFormatOptions) != null ? _b : defaultValue; + title = "Show " + (currentlyShown ? currentValue : showOption); + title += !title.contains("date") ? " date" : ""; + actionNewValue = currentlyShown ? "hide" : showOption; + } else { + impossibleBranch(key2); + } + menu.addItem( + (item) => item.setTitle(title).setSection("obs-git-line-author-configure").setChecked(currentlyShown).onClick( + (_e) => { + var _a3, _b2; + return (_b2 = (_a3 = pluginRef.plugin) == null ? void 0 : _a3.settingsTab) == null ? void 0 : _b2.lineAuthorSettingHandler( + key2, + actionNewValue + ); + } + ) + ); +} +function enrichCommitInfoForContextMenu(commit2, isWaitingGutter, elt) { + elt.setAttr( + COMMIT_ATTR, + JSON.stringify({ + hash: commit2.hash, + isZeroCommit: commit2.isZeroCommit, + isWaitingGutter + }) + ); +} +function getCommitInfo(elt) { + const commitInfoStr = elt.getAttr(COMMIT_ATTR); + return commitInfoStr ? JSON.parse(commitInfoStr) : void 0; +} + +// src/lineAuthor/view/gutter/coloring.ts +init_polyfill_buffer(); +function previewColor(which, settings) { + return which === "oldest" ? coloringBasedOnCommitAge(0, false, settings).color : coloringBasedOnCommitAge(void 0, true, settings).color; +} +function coloringBasedOnCommitAge(commitAuthorEpochSeonds, isZeroCommit, settings) { + const maxAgeInDays = maxAgeInDaysFromSettings(settings); + const epochSecondsNow = Date.now() / 1e3; + const authoringEpochSeconds = commitAuthorEpochSeonds != null ? commitAuthorEpochSeonds : 0; + const secondsSinceCommit = isZeroCommit ? 0 : epochSecondsNow - authoringEpochSeconds; + const daysSinceCommit = secondsSinceCommit / 60 / 60 / 24; + const x = Math.pow( + Math.clamp(daysSinceCommit / maxAgeInDays, 0, 1), + 1 / 2.3 + ); + const dark = isDarkMode(); + const color0 = settings.colorNew; + const color1 = settings.colorOld; + const scaling = dark ? 0.4 : 1; + const r = lin(color0.r, color1.r, x) * scaling; + const g = lin(color0.g, color1.g, x) * scaling; + const b = lin(color0.b, color1.b, x) * scaling; + const a = dark ? 0.75 : 0.25; + return { color: `rgba(${r},${g},${b},${a})`, daysSinceCommit }; +} +function lin(z0, z1, x) { + return z0 + (z1 - z0) * x; +} +function isDarkMode() { + const obsidian = window == null ? void 0 : window.app; + return (obsidian == null ? void 0 : obsidian.getTheme()) === "obsidian"; +} +function setTextColorCssBasedOnSetting(settings) { + document.body.style.setProperty( + "--obs-git-gutter-text", + settings.textColorCss + ); +} + +// src/lineAuthor/view/gutter/commitChoice.ts +init_polyfill_buffer(); +function chooseNewestCommit(lineAuthoring, startLine, endLine) { + let newest = void 0; + for (let line = startLine; line <= endLine; line++) { + const currentHash = lineAuthoring.hashPerLine[line]; + const currentCommit = lineAuthoring.commits.get(currentHash); + if (!newest || currentCommit.isZeroCommit || isNewerThan(currentCommit, newest)) { + newest = currentCommit; + } + } + return newest; +} +function isNewerThan(left, right) { + var _a2, _b, _c, _d; + const l = (_b = (_a2 = left.author) == null ? void 0 : _a2.epochSeconds) != null ? _b : 0; + const r = (_d = (_c = right.author) == null ? void 0 : _c.epochSeconds) != null ? _d : 0; + return l > r; +} + +// src/lineAuthor/view/gutter/gutter.ts +var VALUE_NOT_FOUND_FALLBACK = "-"; +var NEW_CHANGE_CHARACTER = "+"; +var NEW_CHANGE_NUMBER_OF_CHARACTERS = 3; +var DIFFERING_AUTHOR_COMMITTER_MARKER = "*"; +var NON_WHITESPACE_REGEXP = /\S/g; +var UNINTRUSIVE_CHARACTER_FOR_WAITING_RENDERING = "%"; +var TextGutter = class extends import_view.GutterMarker { + constructor(text2) { + super(); + this.text = text2; + } + eq(other) { + return this.text === (other == null ? void 0 : other.text); + } + toDOM() { + return document.createTextNode(this.text); + } + destroy(dom) { + if (!document.body.contains(dom)) + dom.remove(); + } +}; +var LineAuthoringGutter = class extends import_view.GutterMarker { + /** + * **This should only be called {@link lineAuthoringGutterMarker}!** + * + * We want to avoid creating the same instance multiple times for improved performance. + */ + constructor(lineAuthoring, startLine, endLine, key2, settings, options) { + super(); + this.lineAuthoring = lineAuthoring; + this.startLine = startLine; + this.endLine = endLine; + this.key = key2; + this.settings = settings; + this.options = options; + this.point = false; + this.elementClass = "obs-git-blame-gutter"; + } + // Equality used by CodeMirror for optimisations + eq(other) { + return this.key === (other == null ? void 0 : other.key) && this.startLine === (other == null ? void 0 : other.startLine) && this.endLine === (other == null ? void 0 : other.endLine) && (this == null ? void 0 : this.options) === (other == null ? void 0 : other.options); + } + /** + * Renders to a Html node. + * + * It choses the newest commit within the line-range, + * renders it, makes adjustments for fake-commits and finally warps + * it into HTML. + * + * The DOM is actually precomputed with {@link computeDom}, + * which provides a finaliser to run before the DOM is handed over to CodeMirror. + * This is done, because this method is called frequently. It is called, + * whenever a gutter gets into the viewport and needs to be rendered. + * + * The age in days is recorded via {@link recordRenderedAgeInDays} to enable adaptive coloring. + */ + toDOM() { + var _a2; + this.precomputedDomProvider = (_a2 = this.precomputedDomProvider) != null ? _a2 : this.computeDom(); + return this.precomputedDomProvider(); + } + destroy(dom) { + if (!document.body.contains(dom)) { + dom.remove(); + attachedGutterElements.delete(dom); + } + } + /** + * Prepares the DOM for this gutter. + */ + computeDom() { + const commit2 = chooseNewestCommit( + this.lineAuthoring, + this.startLine, + this.endLine + ); + let toBeRenderedText = commit2.isZeroCommit ? "" : this.renderNonZeroCommit(commit2); + const isTrueCommit = !commit2.isZeroCommit && this.options !== "waiting-for-result"; + if (isTrueCommit) { + conditionallyUpdateLongestRenderedGutter(this, toBeRenderedText); + } else { + toBeRenderedText = this.adaptTextForFakeCommit( + commit2, + toBeRenderedText, + this.options + ); + } + const domProvider = this.createHtmlNode( + commit2, + toBeRenderedText, + this.options === "waiting-for-result" + ); + return domProvider; + } + createHtmlNode(commit2, text2, isWaitingGutter) { + var _a2; + const templateElt = window.createDiv(); + templateElt.innerText = text2; + const { color, daysSinceCommit } = coloringBasedOnCommitAge( + (_a2 = commit2 == null ? void 0 : commit2.author) == null ? void 0 : _a2.epochSeconds, + commit2 == null ? void 0 : commit2.isZeroCommit, + this.settings + ); + templateElt.style.backgroundColor = color; + enrichCommitInfoForContextMenu(commit2, isWaitingGutter, templateElt); + function prepareForDomAttachment() { + const elt = templateElt.cloneNode(true); + attachedGutterElements.add(elt); + if (!isWaitingGutter) + recordRenderedAgeInDays(daysSinceCommit); + return elt; + } + return prepareForDomAttachment; + } + renderNonZeroCommit(commit2) { + const optionalShortHash = this.settings.showCommitHash ? this.renderHash(commit2) : ""; + const optionalAuthorName = this.settings.authorDisplay === "hide" ? "" : `${this.renderAuthorName( + commit2, + this.settings.authorDisplay + )}`; + const optionalAuthoringDate = this.settings.dateTimeFormatOptions === "hide" ? "" : `${this.renderAuthoringDate( + commit2, + this.settings.dateTimeFormatOptions, + this.settings.dateTimeFormatCustomString, + this.settings.dateTimeTimezone + )}`; + const parts = [ + optionalShortHash, + optionalAuthorName, + optionalAuthoringDate + ]; + return parts.filter((x) => x.length >= 1).join(" "); + } + renderHash(nonZeroCommit) { + return nonZeroCommit.hash.substring(0, 6); + } + renderAuthorName(nonZeroCommit, authorDisplay) { + var _a2, _b, _c, _d; + const name = (_b = (_a2 = nonZeroCommit == null ? void 0 : nonZeroCommit.author) == null ? void 0 : _a2.name) != null ? _b : ""; + const words = name.split(" ").filter((word) => word.length >= 1); + let rendered; + switch (authorDisplay) { + case "initials": + rendered = words.map((word) => word[0].toUpperCase()).join(""); + break; + case "first name": + rendered = (_c = words.first()) != null ? _c : VALUE_NOT_FOUND_FALLBACK; + break; + case "last name": + rendered = (_d = words.last()) != null ? _d : VALUE_NOT_FOUND_FALLBACK; + break; + case "full": + rendered = name; + break; + default: + return impossibleBranch(authorDisplay); + } + if (!strictDeepEqual(nonZeroCommit == null ? void 0 : nonZeroCommit.author, nonZeroCommit == null ? void 0 : nonZeroCommit.committer)) { + rendered = rendered + DIFFERING_AUTHOR_COMMITTER_MARKER; + } + return rendered; + } + renderAuthoringDate(nonZeroCommit, dateTimeFormatOptions, dateTimeFormatCustomString, dateTimeTimezone) { + var _a2; + const FALLBACK_COMMIT_DATE = "?"; + if (((_a2 = nonZeroCommit == null ? void 0 : nonZeroCommit.author) == null ? void 0 : _a2.epochSeconds) === void 0) + return FALLBACK_COMMIT_DATE; + let dateTimeFormatting; + switch (dateTimeFormatOptions) { + case "date": + dateTimeFormatting = DATE_FORMAT; + break; + case "datetime": + dateTimeFormatting = DATE_TIME_FORMAT_MINUTES; + break; + case "custom": + dateTimeFormatting = dateTimeFormatCustomString; + break; + case "natural language": + dateTimeFormatting = (time) => { + const diff2 = time.diff((0, import_obsidian10.moment)()); + const addFluentSuffix = true; + return import_obsidian10.moment.duration(diff2).humanize(addFluentSuffix); + }; + break; + default: + return impossibleBranch(dateTimeFormatOptions); + } + let authoringDate = import_obsidian10.moment.unix( + nonZeroCommit.author.epochSeconds + ); + switch (dateTimeTimezone) { + case "viewer-local": + break; + case "author-local": + authoringDate = authoringDate.utcOffset( + nonZeroCommit.author.tz + ); + dateTimeFormatting += " Z"; + break; + case "utc0000": + authoringDate = authoringDate.utc(); + dateTimeFormatting += "[Z]"; + break; + default: + return impossibleBranch(dateTimeTimezone); + } + if (typeof dateTimeFormatting === "string") { + return authoringDate.format(dateTimeFormatting); + } else { + return dateTimeFormatting(authoringDate); + } + } + adaptTextForFakeCommit(commit2, toBeRenderedText, options) { + var _a2, _b, _c, _d; + const original = (_b = (_a2 = getLongestRenderedGutter()) == null ? void 0 : _a2.text) != null ? _b : toBeRenderedText; + const fillCharacter = options !== "waiting-for-result" && commit2.isZeroCommit ? NEW_CHANGE_CHARACTER : UNINTRUSIVE_CHARACTER_FOR_WAITING_RENDERING; + toBeRenderedText = original.replace( + NON_WHITESPACE_REGEXP, + fillCharacter + ); + const desiredTextLength = (_d = (_c = latestSettings.get()) == null ? void 0 : _c.gutterSpacingFallbackLength) != null ? _d : toBeRenderedText.length; + toBeRenderedText = resizeToLength( + toBeRenderedText, + desiredTextLength, + fillCharacter + ); + if (options !== "waiting-for-result" && commit2.isZeroCommit) { + const numberOfLastCharactersToKeep = Math.min( + desiredTextLength, + NEW_CHANGE_NUMBER_OF_CHARACTERS + ); + toBeRenderedText = prefixOfLengthAsWhitespace( + toBeRenderedText, + desiredTextLength - numberOfLastCharactersToKeep + ); + } + return toBeRenderedText; + } +}; +function lineAuthoringGutterMarker(la, startLine, endLine, key2, settings, options) { + const digest = import_js_sha2562.sha256.create(); + digest.update(Object.values(settings).join(",")); + digest.update(`s${startLine}-e${endLine}-k${key2}-o${options}`); + const cacheKey = digest.hex(); + const cached = gutterInstances.get(cacheKey); + if (cached) + return cached; + const result = new LineAuthoringGutter( + la, + startLine, + endLine, + key2, + settings, + options + ); + gutterInstances.set(cacheKey, result); + return result; +} + +// src/lineAuthor/view/gutter/initial.ts +init_polyfill_buffer(); +var import_obsidian11 = require("obsidian"); +function initialSpacingGutter() { + var _a2, _b; + const length = (_b = (_a2 = latestSettings.get()) == null ? void 0 : _a2.gutterSpacingFallbackLength) != null ? _b : DEFAULT_SETTINGS.lineAuthor.gutterSpacingFallbackLength; + return new TextGutter(Array(length).fill("-").join("")); +} +function initialLineAuthoringGutter(settings) { + const { lineAuthoring, ageForInitialRender } = adaptiveInitialColoredWaitingLineAuthoring(settings); + return lineAuthoringGutterMarker( + lineAuthoring, + 1, + 1, + "initialGutter" + ageForInitialRender, + // use a age coloring based cache key + settings, + "waiting-for-result" + ); +} +function adaptiveInitialColoredWaitingLineAuthoring(settings) { + var _a2; + const ageForInitialRender = (_a2 = computeAdaptiveInitialColoringAgeInDays()) != null ? _a2 : maxAgeInDaysFromSettings(settings) * 0.25; + const slightlyOlderAgeForInitialRender = (0, import_obsidian11.moment)().add( + -ageForInitialRender, + "days" + ); + const dummyAuthor = { + name: "", + epochSeconds: momentToEpochSeconds(slightlyOlderAgeForInitialRender), + tz: "+0000" + }; + const dummyCommit = { + hash: "waiting-for-result", + author: dummyAuthor, + committer: dummyAuthor, + isZeroCommit: false + }; + return { + lineAuthoring: { + hashPerLine: [void 0, "waiting-for-result"], + commits: /* @__PURE__ */ new Map([["waiting-for-result", dummyCommit]]) + }, + ageForInitialRender + }; +} + +// src/lineAuthor/view/gutter/untrackedFile.ts +init_polyfill_buffer(); +function newUntrackedFileGutter(key2, settings) { + const dummyLineAuthoring = { + hashPerLine: [void 0, "000000"], + commits: /* @__PURE__ */ new Map([["000000", zeroCommit]]) + }; + return lineAuthoringGutterMarker(dummyLineAuthoring, 1, 1, key2, settings); +} + +// src/lineAuthor/view/view.ts +var UNDISPLAYED = new TextGutter(""); +var lineAuthorGutter = (0, import_view2.gutter)({ + class: "line-author-gutter-container", + markers(view) { + const lineAuthoring = view.state.field(lineAuthorState, false); + return lineAuthoringGutterMarkersRangeSet(view, lineAuthoring); + }, + lineMarkerChange(update2) { + const newLineAuthoringId = laStateDigest( + update2.state.field(lineAuthorState) + ); + const oldLineAuthoringId = laStateDigest( + update2.startState.field(lineAuthorState) + ); + return oldLineAuthoringId !== newLineAuthoringId; + }, + renderEmptyElements: true, + initialSpacer: (view) => { + temporaryWorkaroundGutterSpacingForRenderedLineAuthoring(view); + return initialSpacingGutter(); + }, + updateSpacer: (_sp, update2) => { + var _a2, _b; + temporaryWorkaroundGutterSpacingForRenderedLineAuthoring(update2.view); + return (_b = (_a2 = getLongestRenderedGutter()) == null ? void 0 : _a2.gutter) != null ? _b : initialSpacingGutter(); + } +}); +function lineAuthoringGutterMarkersRangeSet(view, optLA) { + const digest = laStateDigest(optLA); + const doc = view.state.doc; + const lineBlockEndPos = /* @__PURE__ */ new Map(); + for (let line = 1; line <= doc.lines; line++) { + const from = doc.line(line).from; + const to = view.lineBlockAt(from).to; + lineBlockEndPos.set(line, [from, to]); + digest.update([from, to, 0]); + } + const laSettings = latestSettings.get(); + digest.update("s" + Object.values(latestSettings).join(",")); + const cacheKey = digest.hex(); + const cached = gutterMarkersRangeSet.get(cacheKey); + if (cached) + return cached; + const { result, allowCache } = computeLineAuthoringGutterMarkersRangeSet( + doc, + lineBlockEndPos, + laSettings, + optLA + ); + if (allowCache) + gutterMarkersRangeSet.set(cacheKey, result); + return result; +} +function computeLineAuthoringGutterMarkersRangeSet(doc, blocksPerLine, settings, optLA) { + let allowCache = true; + const docLastLine = doc.lines; + const ranges = []; + function add2(from, to, gutter2) { + return ranges.push(gutter2.range(from, to)); + } + const lineFrom = computeLineMappingForUnsavedChanges(docLastLine, optLA); + const emptyDoc = doc.length === 0; + const lastLineIsEmpty = doc.iterLines(docLastLine, docLastLine + 1).next().value === ""; + for (let startLine = 1; startLine <= docLastLine; startLine++) { + const [from, to] = blocksPerLine.get(startLine); + const endLine = doc.lineAt(to).number; + if (emptyDoc) { + add2(from, to, UNDISPLAYED); + continue; + } + if (startLine === docLastLine && lastLineIsEmpty) { + add2(from, to, UNDISPLAYED); + continue; + } + if (optLA === void 0) { + add2(from, to, initialLineAuthoringGutter(settings)); + allowCache = false; + continue; + } + const { key: key2, la } = optLA; + if (la === "untracked") { + add2(from, to, newUntrackedFileGutter(la, settings)); + continue; + } + const lastAuthorLine = la.hashPerLine.length - 1; + const laStartLine = lineFrom[startLine]; + const laEndLine = lineFrom[endLine]; + if (laEndLine && laEndLine > lastAuthorLine) { + add2(from, to, UNDISPLAYED); + } + if (laStartLine !== void 0 && between(1, laStartLine, lastAuthorLine) && laEndLine !== void 0 && between(1, laEndLine, lastAuthorLine)) { + add2( + from, + to, + lineAuthoringGutterMarker( + la, + laStartLine, + laEndLine, + key2, + settings + ) + ); + continue; + } + if (lastAuthorLine < 1) { + add2(from, to, initialLineAuthoringGutter(settings)); + allowCache = false; + continue; + } + const start = Math.clamp(laStartLine != null ? laStartLine : startLine, 1, lastAuthorLine); + const end = Math.clamp(laEndLine != null ? laEndLine : endLine, 1, lastAuthorLine); + add2( + from, + to, + lineAuthoringGutterMarker( + la, + start, + end, + key2 + "computing", + settings, + "waiting-for-result" + ) + ); + } + return { result: import_state3.RangeSet.of( + ranges, + /* sort = */ + true + ), allowCache }; +} +function computeLineMappingForUnsavedChanges(docLastLine, optLA) { + if (!(optLA == null ? void 0 : optLA.lineOffsetsFromUnsavedChanges)) { + return Array.from(new Array(docLastLine + 1), (ln) => ln); + } + const lineFrom = [void 0]; + let cumulativeLineOffset = 0; + for (let ln = 1; ln <= docLastLine; ln++) { + const unsavedChanges = optLA.lineOffsetsFromUnsavedChanges.get(ln); + cumulativeLineOffset += unsavedChanges != null ? unsavedChanges : 0; + lineFrom[ln] = unsavedChanges === void 0 ? ln - cumulativeLineOffset : void 0; + } + return lineFrom; +} +function temporaryWorkaroundGutterSpacingForRenderedLineAuthoring(view) { + const guttersContainers = view.dom.querySelectorAll( + ".cm-gutters" + ); + guttersContainers.forEach((cont) => { + if (!(cont == null ? void 0 : cont.style)) + return; + if (!cont.style.marginLeft) { + cont.style.marginLeft = "unset"; + } + }); +} + +// src/lineAuthor/lineAuthorProvider.ts +var LineAuthorProvider = class { + constructor(plugin) { + this.plugin = plugin; + /** + * Saves all computed line authoring results. + * + * See {@link LineAuthoringId} + */ + this.lineAuthorings = /* @__PURE__ */ new Map(); + } + async trackChanged(file) { + this.trackChangedHelper(file).catch((reason) => { + console.warn("Obsidian Git: Error in trackChanged." + reason); + return Promise.reject(reason); + }); + } + async trackChangedHelper(file) { + if (!file) + return; + if (file.path === void 0) { + console.warn( + "Obsidian Git: Attempted to track change of undefined filepath. Unforeseen situation." + ); + return; + } + this.computeLineAuthorInfo(file.path); + } + destroy() { + this.lineAuthorings.clear(); + eventsPerFilePathSingleton.clear(); + clearViewCache(); + } + async computeLineAuthorInfo(filepath) { + const gitManager = this.plugin.lineAuthoringFeature.isAvailableOnCurrentPlatform().gitManager; + const headRevision = await gitManager.submoduleAwareHeadRevisonInContainingDirectory( + filepath + ); + const fileHash = await gitManager.hashObject(filepath); + const key2 = lineAuthoringId(headRevision, fileHash, filepath); + if (key2 === void 0) { + return; + } + if (this.lineAuthorings.has(key2)) { + } else { + const gitAuthorResult = await gitManager.blame( + filepath, + this.plugin.settings.lineAuthor.followMovement, + this.plugin.settings.lineAuthor.ignoreWhitespace + ); + this.lineAuthorings.set(key2, gitAuthorResult); + } + this.notifyComputationResultToSubscribers(filepath, key2); + } + notifyComputationResultToSubscribers(filepath, key2) { + eventsPerFilePathSingleton.ifFilepathDefinedTransformSubscribers( + filepath, + async (subs) => subs.forEach( + (sub) => sub.notifyLineAuthoring(key2, this.lineAuthorings.get(key2)) + ) + ); + } +}; +var enabledLineAuthorInfoExtensions = import_state4.Prec.high([ + subscribeNewEditor, + lineAuthorState, + lineAuthorGutter +]); + +// src/lineAuthor/lineAuthorIntegration.ts +var LineAuthoringFeature = class { + constructor(plg) { + this.plg = plg; + this.codeMirrorExtensions = []; + this.handleWorkspaceLeaf = (leaf) => { + const obsView = leaf == null ? void 0 : leaf.view; + const file = obsView == null ? void 0 : obsView.file; + if (!this.lineAuthorInfoProvider) { + console.warn( + "Obsidian Git: undefined lineAuthorInfoProvider. Unexpected situation." + ); + return; + } + if (file === void 0 || (obsView == null ? void 0 : obsView.allowNoFile) === true) + return; + this.lineAuthorInfoProvider.trackChanged(file); + }; + } + // ========================= INIT and DE-INIT ========================== + onLoadPlugin() { + this.plg.registerEditorExtension(this.codeMirrorExtensions); + provideSettingsAccess( + () => this.plg.settings.lineAuthor, + (laSettings) => { + this.plg.settings.lineAuthor = laSettings; + this.plg.saveSettings(); + } + ); + } + conditionallyActivateBySettings() { + if (this.plg.settings.lineAuthor.show) { + this.activateFeature(); + } + } + activateFeature() { + try { + if (!this.isAvailableOnCurrentPlatform()) + return; + setTextColorCssBasedOnSetting(this.plg.settings.lineAuthor); + this.lineAuthorInfoProvider = new LineAuthorProvider(this.plg); + this.createEventHandlers(); + this.activateCodeMirrorExtensions(); + console.log(this.plg.manifest.name + ": Enabled line authoring."); + } catch (e) { + console.warn( + "Obsidian Git: Error while loading line authoring feature.", + e + ); + this.deactivateFeature(); + } + } + /** + * Deactivates the feature. This function is very defensive, as it is also + * called to cleanup, if a critical error in the line authoring has occurred. + */ + deactivateFeature() { + var _a2; + this.destroyEventHandlers(); + this.deactivateCodeMirrorExtensions(); + (_a2 = this.lineAuthorInfoProvider) == null ? void 0 : _a2.destroy(); + this.lineAuthorInfoProvider = void 0; + console.log(this.plg.manifest.name + ": Disabled line authoring."); + } + isAvailableOnCurrentPlatform() { + return { + available: this.plg.useSimpleGit && import_obsidian12.Platform.isDesktopApp, + gitManager: this.plg.gitManager instanceof SimpleGit ? this.plg.gitManager : void 0 + }; + } + // ========================= REFRESH ========================== + refreshLineAuthorViews() { + if (this.plg.settings.lineAuthor.show) { + this.deactivateFeature(); + this.activateFeature(); + } + } + // ========================= CODEMIRROR EXTENSIONS ========================== + activateCodeMirrorExtensions() { + this.codeMirrorExtensions.push(enabledLineAuthorInfoExtensions); + this.plg.app.workspace.updateOptions(); + this.plg.app.workspace.iterateAllLeaves(this.handleWorkspaceLeaf); + } + deactivateCodeMirrorExtensions() { + for (const ext of this.codeMirrorExtensions) { + this.codeMirrorExtensions.remove(ext); + } + this.plg.app.workspace.updateOptions(); + } + // ========================= HANDLERS ========================== + createEventHandlers() { + this.gutterContextMenuEvent = this.createGutterContextMenuHandler(); + this.fileOpenEvent = this.createFileOpenEvent(); + this.workspaceLeafChangeEvent = this.createWorkspaceLeafChangeEvent(); + this.fileModificationEvent = this.createVaultFileModificationHandler(); + this.refreshOnCssChangeEvent = this.createCssRefreshHandler(); + this.fileRenameEvent = this.createFileRenameEvent(); + prepareGutterSearchForContextMenuHandling(); + this.plg.registerEvent(this.gutterContextMenuEvent); + this.plg.registerEvent(this.refreshOnCssChangeEvent); + this.plg.registerEvent(this.fileOpenEvent); + this.plg.registerEvent(this.workspaceLeafChangeEvent); + this.plg.registerEvent(this.fileModificationEvent); + this.plg.registerEvent(this.fileRenameEvent); + } + destroyEventHandlers() { + this.plg.app.workspace.offref(this.refreshOnCssChangeEvent); + this.plg.app.workspace.offref(this.fileOpenEvent); + this.plg.app.workspace.offref(this.workspaceLeafChangeEvent); + this.plg.app.workspace.offref(this.refreshOnCssChangeEvent); + this.plg.app.vault.offref(this.fileRenameEvent); + this.plg.app.workspace.offref(this.gutterContextMenuEvent); + } + createFileOpenEvent() { + return this.plg.app.workspace.on( + "file-open", + (file) => { + var _a2; + return (_a2 = this.lineAuthorInfoProvider) == null ? void 0 : _a2.trackChanged(file); + } + ); + } + createWorkspaceLeafChangeEvent() { + return this.plg.app.workspace.on( + "active-leaf-change", + this.handleWorkspaceLeaf + ); + } + createFileRenameEvent() { + return this.plg.app.vault.on( + "rename", + (file, _old) => { + var _a2; + return file instanceof import_obsidian12.TFile && ((_a2 = this.lineAuthorInfoProvider) == null ? void 0 : _a2.trackChanged(file)); + } + ); + } + createVaultFileModificationHandler() { + return this.plg.app.vault.on( + "modify", + (anyPath) => { + var _a2; + return anyPath instanceof import_obsidian12.TFile && ((_a2 = this.lineAuthorInfoProvider) == null ? void 0 : _a2.trackChanged(anyPath)); + } + ); + } + createCssRefreshHandler() { + return this.plg.app.workspace.on( + "css-change", + () => this.refreshLineAuthorViews() + ); + } + createGutterContextMenuHandler() { + return this.plg.app.workspace.on("editor-menu", handleContextMenu); + } +}; + +// src/promiseQueue.ts +init_polyfill_buffer(); +var PromiseQueue = class { + constructor() { + this.tasks = []; + } + addTask(task) { + this.tasks.push(task); + if (this.tasks.length === 1) { + this.handleTask(); + } + } + async handleTask() { + if (this.tasks.length > 0) { + this.tasks[0]().finally(() => { + this.tasks.shift(); + this.handleTask(); + }); + } + } +}; + +// src/statusBar.ts +init_polyfill_buffer(); +var import_obsidian13 = require("obsidian"); +var StatusBar = class { + constructor(statusBarEl, plugin) { + this.statusBarEl = statusBarEl; + this.plugin = plugin; + this.messages = []; + this.base = "obsidian-git-statusbar-"; + this.statusBarEl.setAttribute("aria-label-position", "top"); + addEventListener("git-refresh", this.refreshCommitTimestamp.bind(this)); + } + displayMessage(message, timeout) { + this.messages.push({ + message: `Git: ${message.slice(0, 100)}`, + timeout + }); + this.display(); + } + display() { + if (this.messages.length > 0 && !this.currentMessage) { + this.currentMessage = this.messages.shift(); + this.statusBarEl.addClass(this.base + "message"); + this.statusBarEl.ariaLabel = ""; + this.statusBarEl.setText(this.currentMessage.message); + this.lastMessageTimestamp = Date.now(); + } else if (this.currentMessage) { + const messageAge = Date.now() - this.lastMessageTimestamp; + if (messageAge >= this.currentMessage.timeout) { + this.currentMessage = null; + this.lastMessageTimestamp = null; + } + } else { + this.displayState(); + } + } + displayState() { + if (this.statusBarEl.getText().length > 3 || !this.statusBarEl.hasChildNodes()) { + this.statusBarEl.empty(); + this.iconEl = this.statusBarEl.createDiv(); + this.textEl = this.statusBarEl.createDiv(); + this.textEl.style.float = "right"; + this.textEl.style.marginLeft = "5px"; + this.iconEl.style.float = "left"; + } + switch (this.plugin.state) { + case 0 /* idle */: + this.displayFromNow(); + break; + case 1 /* status */: + this.statusBarEl.ariaLabel = "Checking repository status..."; + (0, import_obsidian13.setIcon)(this.iconEl, "refresh-cw"); + this.statusBarEl.addClass(this.base + "status"); + break; + case 3 /* add */: + this.statusBarEl.ariaLabel = "Adding files..."; + (0, import_obsidian13.setIcon)(this.iconEl, "refresh-w"); + this.statusBarEl.addClass(this.base + "add"); + break; + case 4 /* commit */: + this.statusBarEl.ariaLabel = "Committing changes..."; + (0, import_obsidian13.setIcon)(this.iconEl, "git-commit"); + this.statusBarEl.addClass(this.base + "commit"); + break; + case 5 /* push */: + this.statusBarEl.ariaLabel = "Pushing changes..."; + (0, import_obsidian13.setIcon)(this.iconEl, "upload"); + this.statusBarEl.addClass(this.base + "push"); + break; + case 2 /* pull */: + this.statusBarEl.ariaLabel = "Pulling changes..."; + (0, import_obsidian13.setIcon)(this.iconEl, "download"); + this.statusBarEl.addClass(this.base + "pull"); + break; + case 6 /* conflicted */: + this.statusBarEl.ariaLabel = "You have conflict files..."; + (0, import_obsidian13.setIcon)(this.iconEl, "alert-circle"); + this.statusBarEl.addClass(this.base + "conflict"); + break; + default: + this.statusBarEl.ariaLabel = "Failed on initialization!"; + (0, import_obsidian13.setIcon)(this.iconEl, "alert-triangle"); + this.statusBarEl.addClass(this.base + "failed-init"); + break; + } + } + displayFromNow() { + var _a2; + const timestamp = this.lastCommitTimestamp; + if (timestamp) { + const moment5 = window.moment; + const fromNow = moment5(timestamp).fromNow(); + this.statusBarEl.ariaLabel = `${this.plugin.offlineMode ? "Offline: " : ""}Last Commit: ${fromNow}`; + if ((_a2 = this.unPushedCommits) != null ? _a2 : 0 > 0) { + this.statusBarEl.ariaLabel += ` +(${this.unPushedCommits} unpushed commits)`; + } + } else { + this.statusBarEl.ariaLabel = this.plugin.offlineMode ? "Git is offline" : "Git is ready"; + } + if (this.plugin.offlineMode) { + (0, import_obsidian13.setIcon)(this.iconEl, "globe"); + } else { + (0, import_obsidian13.setIcon)(this.iconEl, "check"); + } + if (this.plugin.settings.changedFilesInStatusBar && this.plugin.cachedStatus) { + this.textEl.setText( + this.plugin.cachedStatus.changed.length.toString() + ); + } + this.statusBarEl.addClass(this.base + "idle"); + } + async refreshCommitTimestamp() { + this.lastCommitTimestamp = await this.plugin.gitManager.getLastCommitTime(); + this.unPushedCommits = await this.plugin.gitManager.getUnpushedCommits(); + } +}; + +// src/ui/modals/changedFilesModal.ts +init_polyfill_buffer(); +var import_obsidian14 = require("obsidian"); +var ChangedFilesModal = class extends import_obsidian14.FuzzySuggestModal { + constructor(plugin, changedFiles) { + super(plugin.app); + this.plugin = plugin; + this.changedFiles = changedFiles; + this.setPlaceholder( + "Not supported files will be opened by default app!" + ); + } + getItems() { + return this.changedFiles; + } + getItemText(item) { + if (item.index == "U" && item.working_dir == "U") { + return `Untracked | ${item.vault_path}`; + } + let working_dir = ""; + let index2 = ""; + if (item.working_dir != " ") + working_dir = `Working dir: ${item.working_dir} `; + if (item.index != " ") + index2 = `Index: ${item.index}`; + return `${working_dir}${index2} | ${item.vault_path}`; + } + onChooseItem(item, _) { + if (this.plugin.app.metadataCache.getFirstLinkpathDest( + item.vault_path, + "" + ) == null) { + this.app.openWithDefaultApp(item.vault_path); + } else { + this.plugin.app.workspace.openLinkText(item.vault_path, "/"); + } + } +}; + +// src/ui/modals/customMessageModal.ts +init_polyfill_buffer(); +var import_obsidian15 = require("obsidian"); +var CustomMessageModal = class extends import_obsidian15.SuggestModal { + constructor(plugin, fromAutoBackup) { + super(plugin.app); + this.fromAutoBackup = fromAutoBackup; + this.resolve = null; + this.plugin = plugin; + this.setPlaceholder( + "Type your message and select optional the version with the added date." + ); + } + open() { + super.open(); + return new Promise((resolve) => { + this.resolve = resolve; + }); + } + onClose() { + if (this.resolve) + this.resolve(void 0); + } + selectSuggestion(value, evt) { + if (this.resolve) + this.resolve(value); + super.selectSuggestion(value, evt); + } + getSuggestions(query) { + const date = window.moment().format(this.plugin.settings.commitDateFormat); + if (query == "") + query = "..."; + return [query, `${date}: ${query}`, `${query}: ${date}`]; + } + renderSuggestion(value, el) { + el.innerText = value; + } + onChooseSuggestion(item, _) { + } +}; + +// src/openInGitHub.ts +init_polyfill_buffer(); +var import_obsidian16 = require("obsidian"); +async function openLineInGitHub(editor, file, manager) { + const data = await getData(manager); + if (data.result === "failure") { + new import_obsidian16.Notice(data.reason); + return; + } + const { isGitHub, branch: branch2, repo, user } = data; + if (isGitHub) { + const path2 = manager.asRepositoryRelativePath(file.path, true); + const from = editor.getCursor("from").line + 1; + const to = editor.getCursor("to").line + 1; + if (from === to) { + window.open( + `https://github.com/${user}/${repo}/blob/${branch2}/${path2}?plain=1#L${from}` + ); + } else { + window.open( + `https://github.com/${user}/${repo}/blob/${branch2}/${path2}?plain=1#L${from}-L${to}` + ); + } + } else { + new import_obsidian16.Notice("It seems like you are not using GitHub"); + } +} +async function openHistoryInGitHub(file, manager) { + const data = await getData(manager); + if (data.result === "failure") { + new import_obsidian16.Notice(data.reason); + return; + } + const { isGitHub, branch: branch2, repo, user } = data; + const path2 = manager.asRepositoryRelativePath(file.path, true); + if (isGitHub) { + window.open( + `https://github.com/${user}/${repo}/commits/${branch2}/${path2}` + ); + } else { + new import_obsidian16.Notice("It seems like you are not using GitHub"); + } +} +async function getData(manager) { + const branchInfo = await manager.branchInfo(); + const remoteBranch = branchInfo.tracking; + const branch2 = branchInfo.current; + if (remoteBranch == null) { + return { + result: "failure", + reason: "Remote branch is not configured" + }; + } + if (branch2 == null) { + return { + result: "failure", + reason: "Failed to get current branch name" + }; + } + const remote = remoteBranch.substring(0, remoteBranch.indexOf("/")); + const remoteUrl = await manager.getConfig( + `remote.${remote}.url` + ); + const [isGitHub, httpsUser, httpsRepo, sshUser, sshRepo] = remoteUrl.match( + /(?:^https:\/\/github\.com\/(.*)\/(.*)\.git$)|(?:^git@github\.com:(.*)\/(.*)\.git$)/ + ); + return { + result: "success", + isGitHub: !!isGitHub, + repo: httpsRepo || sshRepo, + user: httpsUser || sshUser, + branch: branch2 + }; +} + +// src/setting/localStorageSettings.ts +init_polyfill_buffer(); +var LocalStorageSettings = class { + constructor(plugin) { + this.plugin = plugin; + this.prefix = this.plugin.manifest.id + ":"; + } + migrate() { + const keys = [ + "password", + "hostname", + "conflict", + "lastAutoPull", + "lastAutoBackup", + "lastAutoPush", + "gitPath", + "pluginDisabled" + ]; + for (const key2 of keys) { + const old = localStorage.getItem(this.prefix + key2); + if (app.loadLocalStorage(this.prefix + key2) == null && old != null) { + if (old != null) { + app.saveLocalStorage(this.prefix + key2, old); + localStorage.removeItem(this.prefix + key2); + } + } + } + } + getPassword() { + return app.loadLocalStorage(this.prefix + "password"); + } + setPassword(value) { + return app.saveLocalStorage(this.prefix + "password", value); + } + getUsername() { + return app.loadLocalStorage(this.prefix + "username"); + } + setUsername(value) { + return app.saveLocalStorage(this.prefix + "username", value); + } + getHostname() { + return app.loadLocalStorage(this.prefix + "hostname"); + } + setHostname(value) { + return app.saveLocalStorage(this.prefix + "hostname", value); + } + getConflict() { + return app.loadLocalStorage(this.prefix + "conflict"); + } + setConflict(value) { + return app.saveLocalStorage(this.prefix + "conflict", value); + } + getLastAutoPull() { + return app.loadLocalStorage(this.prefix + "lastAutoPull"); + } + setLastAutoPull(value) { + return app.saveLocalStorage(this.prefix + "lastAutoPull", value); + } + getLastAutoBackup() { + return app.loadLocalStorage(this.prefix + "lastAutoBackup"); + } + setLastAutoBackup(value) { + return app.saveLocalStorage(this.prefix + "lastAutoBackup", value); + } + getLastAutoPush() { + return app.loadLocalStorage(this.prefix + "lastAutoPush"); + } + setLastAutoPush(value) { + return app.saveLocalStorage(this.prefix + "lastAutoPush", value); + } + getGitPath() { + return app.loadLocalStorage(this.prefix + "gitPath"); + } + setGitPath(value) { + return app.saveLocalStorage(this.prefix + "gitPath", value); + } + getPATHPaths() { + var _a2, _b; + return (_b = (_a2 = app.loadLocalStorage(this.prefix + "PATHPaths")) == null ? void 0 : _a2.split(":")) != null ? _b : []; + } + setPATHPaths(value) { + return app.saveLocalStorage(this.prefix + "PATHPaths", value.join(":")); + } + getEnvVars() { + var _a2; + return JSON.parse( + (_a2 = app.loadLocalStorage(this.prefix + "envVars")) != null ? _a2 : "[]" + ); + } + setEnvVars(value) { + return app.saveLocalStorage( + this.prefix + "envVars", + JSON.stringify(value) + ); + } + getPluginDisabled() { + return app.loadLocalStorage(this.prefix + "pluginDisabled") == "true"; + } + setPluginDisabled(value) { + return app.saveLocalStorage(this.prefix + "pluginDisabled", `${value}`); + } +}; + +// src/ui/diff/diffView.ts +init_polyfill_buffer(); + +// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/diff2html.js +init_polyfill_buffer(); + +// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/diff-parser.js +init_polyfill_buffer(); + +// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/types.js +init_polyfill_buffer(); +var LineType; +(function(LineType2) { + LineType2["INSERT"] = "insert"; + LineType2["DELETE"] = "delete"; + LineType2["CONTEXT"] = "context"; +})(LineType || (LineType = {})); +var OutputFormatType = { + LINE_BY_LINE: "line-by-line", + SIDE_BY_SIDE: "side-by-side" +}; +var LineMatchingType = { + LINES: "lines", + WORDS: "words", + NONE: "none" +}; +var DiffStyleType = { + WORD: "word", + CHAR: "char" +}; + +// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/utils.js +init_polyfill_buffer(); +var specials = [ + "-", + "[", + "]", + "/", + "{", + "}", + "(", + ")", + "*", + "+", + "?", + ".", + "\\", + "^", + "$", + "|" +]; +var regex = RegExp("[" + specials.join("\\") + "]", "g"); +function escapeForRegExp(str) { + return str.replace(regex, "\\$&"); +} +function unifyPath(path2) { + return path2 ? path2.replace(/\\/g, "/") : path2; +} +function hashCode(text2) { + var i, chr, len; + var hash2 = 0; + for (i = 0, len = text2.length; i < len; i++) { + chr = text2.charCodeAt(i); + hash2 = (hash2 << 5) - hash2 + chr; + hash2 |= 0; + } + return hash2; +} + +// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/diff-parser.js +var __spreadArray = function(to, from, pack) { + if (pack || arguments.length === 2) + for (var i = 0, l = from.length, ar; i < l; i++) { + if (ar || !(i in from)) { + if (!ar) + ar = Array.prototype.slice.call(from, 0, i); + ar[i] = from[i]; + } + } + return to.concat(ar || Array.prototype.slice.call(from)); +}; +function getExtension(filename, language) { + var filenameParts = filename.split("."); + return filenameParts.length > 1 ? filenameParts[filenameParts.length - 1] : language; +} +function startsWithAny(str, prefixes) { + return prefixes.reduce(function(startsWith, prefix) { + return startsWith || str.startsWith(prefix); + }, false); +} +var baseDiffFilenamePrefixes = ["a/", "b/", "i/", "w/", "c/", "o/"]; +function getFilename(line, linePrefix, extraPrefix) { + var prefixes = extraPrefix !== void 0 ? __spreadArray(__spreadArray([], baseDiffFilenamePrefixes, true), [extraPrefix], false) : baseDiffFilenamePrefixes; + var FilenameRegExp = linePrefix ? new RegExp("^".concat(escapeForRegExp(linePrefix), ' "?(.+?)"?$')) : new RegExp('^"?(.+?)"?$'); + var _a2 = FilenameRegExp.exec(line) || [], _b = _a2[1], filename = _b === void 0 ? "" : _b; + var matchingPrefix = prefixes.find(function(p) { + return filename.indexOf(p) === 0; + }); + var fnameWithoutPrefix = matchingPrefix ? filename.slice(matchingPrefix.length) : filename; + return fnameWithoutPrefix.replace(/\s+\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d+)? [+-]\d{4}.*$/, ""); +} +function getSrcFilename(line, srcPrefix) { + return getFilename(line, "---", srcPrefix); +} +function getDstFilename(line, dstPrefix) { + return getFilename(line, "+++", dstPrefix); +} +function parse(diffInput, config) { + if (config === void 0) { + config = {}; + } + var files = []; + var currentFile = null; + var currentBlock = null; + var oldLine = null; + var oldLine2 = null; + var newLine = null; + var possibleOldName = null; + var possibleNewName = null; + var oldFileNameHeader = "--- "; + var newFileNameHeader = "+++ "; + var hunkHeaderPrefix = "@@"; + var oldMode = /^old mode (\d{6})/; + var newMode = /^new mode (\d{6})/; + var deletedFileMode = /^deleted file mode (\d{6})/; + var newFileMode = /^new file mode (\d{6})/; + var copyFrom = /^copy from "?(.+)"?/; + var copyTo = /^copy to "?(.+)"?/; + var renameFrom = /^rename from "?(.+)"?/; + var renameTo = /^rename to "?(.+)"?/; + var similarityIndex = /^similarity index (\d+)%/; + var dissimilarityIndex = /^dissimilarity index (\d+)%/; + var index2 = /^index ([\da-z]+)\.\.([\da-z]+)\s*(\d{6})?/; + var binaryFiles = /^Binary files (.*) and (.*) differ/; + var binaryDiff = /^GIT binary patch/; + var combinedIndex = /^index ([\da-z]+),([\da-z]+)\.\.([\da-z]+)/; + var combinedMode = /^mode (\d{6}),(\d{6})\.\.(\d{6})/; + var combinedNewFile = /^new file mode (\d{6})/; + var combinedDeletedFile = /^deleted file mode (\d{6}),(\d{6})/; + var diffLines2 = diffInput.replace(/\\ No newline at end of file/g, "").replace(/\r\n?/g, "\n").split("\n"); + function saveBlock() { + if (currentBlock !== null && currentFile !== null) { + currentFile.blocks.push(currentBlock); + currentBlock = null; + } + } + function saveFile() { + if (currentFile !== null) { + if (!currentFile.oldName && possibleOldName !== null) { + currentFile.oldName = possibleOldName; + } + if (!currentFile.newName && possibleNewName !== null) { + currentFile.newName = possibleNewName; + } + if (currentFile.newName) { + files.push(currentFile); + currentFile = null; + } + } + possibleOldName = null; + possibleNewName = null; + } + function startFile() { + saveBlock(); + saveFile(); + currentFile = { + blocks: [], + deletedLines: 0, + addedLines: 0 + }; + } + function startBlock(line) { + saveBlock(); + var values; + if (currentFile !== null) { + if (values = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@.*/.exec(line)) { + currentFile.isCombined = false; + oldLine = parseInt(values[1], 10); + newLine = parseInt(values[2], 10); + } else if (values = /^@@@ -(\d+)(?:,\d+)? -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@@.*/.exec(line)) { + currentFile.isCombined = true; + oldLine = parseInt(values[1], 10); + oldLine2 = parseInt(values[2], 10); + newLine = parseInt(values[3], 10); + } else { + if (line.startsWith(hunkHeaderPrefix)) { + console.error("Failed to parse lines, starting in 0!"); + } + oldLine = 0; + newLine = 0; + currentFile.isCombined = false; + } + } + currentBlock = { + lines: [], + oldStartLine: oldLine, + oldStartLine2: oldLine2, + newStartLine: newLine, + header: line + }; + } + function createLine(line) { + if (currentFile === null || currentBlock === null || oldLine === null || newLine === null) + return; + var currentLine = { + content: line + }; + var addedPrefixes = currentFile.isCombined ? ["+ ", " +", "++"] : ["+"]; + var deletedPrefixes = currentFile.isCombined ? ["- ", " -", "--"] : ["-"]; + if (startsWithAny(line, addedPrefixes)) { + currentFile.addedLines++; + currentLine.type = LineType.INSERT; + currentLine.oldNumber = void 0; + currentLine.newNumber = newLine++; + } else if (startsWithAny(line, deletedPrefixes)) { + currentFile.deletedLines++; + currentLine.type = LineType.DELETE; + currentLine.oldNumber = oldLine++; + currentLine.newNumber = void 0; + } else { + currentLine.type = LineType.CONTEXT; + currentLine.oldNumber = oldLine++; + currentLine.newNumber = newLine++; + } + currentBlock.lines.push(currentLine); + } + function existHunkHeader(line, lineIdx) { + var idx = lineIdx; + while (idx < diffLines2.length - 3) { + if (line.startsWith("diff")) { + return false; + } + if (diffLines2[idx].startsWith(oldFileNameHeader) && diffLines2[idx + 1].startsWith(newFileNameHeader) && diffLines2[idx + 2].startsWith(hunkHeaderPrefix)) { + return true; + } + idx++; + } + return false; + } + diffLines2.forEach(function(line, lineIndex) { + if (!line || line.startsWith("*")) { + return; + } + var values; + var prevLine = diffLines2[lineIndex - 1]; + var nxtLine = diffLines2[lineIndex + 1]; + var afterNxtLine = diffLines2[lineIndex + 2]; + if (line.startsWith("diff --git") || line.startsWith("diff --combined")) { + startFile(); + var gitDiffStart = /^diff --git "?([a-ciow]\/.+)"? "?([a-ciow]\/.+)"?/; + if (values = gitDiffStart.exec(line)) { + possibleOldName = getFilename(values[1], void 0, config.dstPrefix); + possibleNewName = getFilename(values[2], void 0, config.srcPrefix); + } + if (currentFile === null) { + throw new Error("Where is my file !!!"); + } + currentFile.isGitDiff = true; + return; + } + if (line.startsWith("Binary files") && !(currentFile === null || currentFile === void 0 ? void 0 : currentFile.isGitDiff)) { + startFile(); + var unixDiffBinaryStart = /^Binary files "?([a-ciow]\/.+)"? and "?([a-ciow]\/.+)"? differ/; + if (values = unixDiffBinaryStart.exec(line)) { + possibleOldName = getFilename(values[1], void 0, config.dstPrefix); + possibleNewName = getFilename(values[2], void 0, config.srcPrefix); + } + if (currentFile === null) { + throw new Error("Where is my file !!!"); + } + currentFile.isBinary = true; + return; + } + if (!currentFile || !currentFile.isGitDiff && currentFile && line.startsWith(oldFileNameHeader) && nxtLine.startsWith(newFileNameHeader) && afterNxtLine.startsWith(hunkHeaderPrefix)) { + startFile(); + } + if (currentFile === null || currentFile === void 0 ? void 0 : currentFile.isTooBig) { + return; + } + if (currentFile && (typeof config.diffMaxChanges === "number" && currentFile.addedLines + currentFile.deletedLines > config.diffMaxChanges || typeof config.diffMaxLineLength === "number" && line.length > config.diffMaxLineLength)) { + currentFile.isTooBig = true; + currentFile.addedLines = 0; + currentFile.deletedLines = 0; + currentFile.blocks = []; + currentBlock = null; + var message = typeof config.diffTooBigMessage === "function" ? config.diffTooBigMessage(files.length) : "Diff too big to be displayed"; + startBlock(message); + return; + } + if (line.startsWith(oldFileNameHeader) && nxtLine.startsWith(newFileNameHeader) || line.startsWith(newFileNameHeader) && prevLine.startsWith(oldFileNameHeader)) { + if (currentFile && !currentFile.oldName && line.startsWith("--- ") && (values = getSrcFilename(line, config.srcPrefix))) { + currentFile.oldName = values; + currentFile.language = getExtension(currentFile.oldName, currentFile.language); + return; + } + if (currentFile && !currentFile.newName && line.startsWith("+++ ") && (values = getDstFilename(line, config.dstPrefix))) { + currentFile.newName = values; + currentFile.language = getExtension(currentFile.newName, currentFile.language); + return; + } + } + if (currentFile && (line.startsWith(hunkHeaderPrefix) || currentFile.isGitDiff && currentFile.oldName && currentFile.newName && !currentBlock)) { + startBlock(line); + return; + } + if (currentBlock && (line.startsWith("+") || line.startsWith("-") || line.startsWith(" "))) { + createLine(line); + return; + } + var doesNotExistHunkHeader = !existHunkHeader(line, lineIndex); + if (currentFile === null) { + throw new Error("Where is my file !!!"); + } + if (values = oldMode.exec(line)) { + currentFile.oldMode = values[1]; + } else if (values = newMode.exec(line)) { + currentFile.newMode = values[1]; + } else if (values = deletedFileMode.exec(line)) { + currentFile.deletedFileMode = values[1]; + currentFile.isDeleted = true; + } else if (values = newFileMode.exec(line)) { + currentFile.newFileMode = values[1]; + currentFile.isNew = true; + } else if (values = copyFrom.exec(line)) { + if (doesNotExistHunkHeader) { + currentFile.oldName = values[1]; + } + currentFile.isCopy = true; + } else if (values = copyTo.exec(line)) { + if (doesNotExistHunkHeader) { + currentFile.newName = values[1]; + } + currentFile.isCopy = true; + } else if (values = renameFrom.exec(line)) { + if (doesNotExistHunkHeader) { + currentFile.oldName = values[1]; + } + currentFile.isRename = true; + } else if (values = renameTo.exec(line)) { + if (doesNotExistHunkHeader) { + currentFile.newName = values[1]; + } + currentFile.isRename = true; + } else if (values = binaryFiles.exec(line)) { + currentFile.isBinary = true; + currentFile.oldName = getFilename(values[1], void 0, config.srcPrefix); + currentFile.newName = getFilename(values[2], void 0, config.dstPrefix); + startBlock("Binary file"); + } else if (binaryDiff.test(line)) { + currentFile.isBinary = true; + startBlock(line); + } else if (values = similarityIndex.exec(line)) { + currentFile.unchangedPercentage = parseInt(values[1], 10); + } else if (values = dissimilarityIndex.exec(line)) { + currentFile.changedPercentage = parseInt(values[1], 10); + } else if (values = index2.exec(line)) { + currentFile.checksumBefore = values[1]; + currentFile.checksumAfter = values[2]; + values[3] && (currentFile.mode = values[3]); + } else if (values = combinedIndex.exec(line)) { + currentFile.checksumBefore = [values[2], values[3]]; + currentFile.checksumAfter = values[1]; + } else if (values = combinedMode.exec(line)) { + currentFile.oldMode = [values[2], values[3]]; + currentFile.newMode = values[1]; + } else if (values = combinedNewFile.exec(line)) { + currentFile.newFileMode = values[1]; + currentFile.isNew = true; + } else if (values = combinedDeletedFile.exec(line)) { + currentFile.deletedFileMode = values[1]; + currentFile.isDeleted = true; + } + }); + saveBlock(); + saveFile(); + return files; +} + +// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/file-list-renderer.js +init_polyfill_buffer(); + +// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/render-utils.js +init_polyfill_buffer(); + +// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/rematch.js +init_polyfill_buffer(); +function levenshtein(a, b) { + if (a.length === 0) { + return b.length; + } + if (b.length === 0) { + return a.length; + } + var matrix = []; + var i; + for (i = 0; i <= b.length; i++) { + matrix[i] = [i]; + } + var j; + for (j = 0; j <= a.length; j++) { + matrix[0][j] = j; + } + for (i = 1; i <= b.length; i++) { + for (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, Math.min(matrix[i][j - 1] + 1, matrix[i - 1][j] + 1)); + } + } + } + return matrix[b.length][a.length]; +} +function newDistanceFn(str) { + return function(x, y) { + var xValue = str(x).trim(); + var yValue = str(y).trim(); + var lev = levenshtein(xValue, yValue); + return lev / (xValue.length + yValue.length); + }; +} +function newMatcherFn(distance2) { + function findBestMatch(a, b, cache) { + if (cache === void 0) { + cache = /* @__PURE__ */ new Map(); + } + var bestMatchDist = Infinity; + var bestMatch; + for (var i = 0; i < a.length; ++i) { + for (var j = 0; j < b.length; ++j) { + var cacheKey = JSON.stringify([a[i], b[j]]); + var md = void 0; + if (!(cache.has(cacheKey) && (md = cache.get(cacheKey)))) { + md = distance2(a[i], b[j]); + cache.set(cacheKey, md); + } + if (md < bestMatchDist) { + bestMatchDist = md; + bestMatch = { indexA: i, indexB: j, score: bestMatchDist }; + } + } + } + return bestMatch; + } + function group(a, b, level, cache) { + if (level === void 0) { + level = 0; + } + if (cache === void 0) { + cache = /* @__PURE__ */ new Map(); + } + var bm = findBestMatch(a, b, cache); + if (!bm || a.length + b.length < 3) { + return [[a, b]]; + } + var a1 = a.slice(0, bm.indexA); + var b1 = b.slice(0, bm.indexB); + var aMatch = [a[bm.indexA]]; + var bMatch = [b[bm.indexB]]; + var tailA = bm.indexA + 1; + var tailB = bm.indexB + 1; + var a2 = a.slice(tailA); + var b2 = b.slice(tailB); + var group1 = group(a1, b1, level + 1, cache); + var groupMatch = group(aMatch, bMatch, level + 1, cache); + var group2 = group(a2, b2, level + 1, cache); + var result = groupMatch; + if (bm.indexA > 0 || bm.indexB > 0) { + result = group1.concat(result); + } + if (a.length > tailA || b.length > tailB) { + result = result.concat(group2); + } + return result; + } + return group; +} + +// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/render-utils.js +var __assign = function() { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) + if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +var CSSLineClass = { + INSERTS: "d2h-ins", + DELETES: "d2h-del", + CONTEXT: "d2h-cntx", + INFO: "d2h-info", + INSERT_CHANGES: "d2h-ins d2h-change", + DELETE_CHANGES: "d2h-del d2h-change" +}; +var defaultRenderConfig = { + matching: LineMatchingType.NONE, + matchWordsThreshold: 0.25, + maxLineLengthHighlight: 1e4, + diffStyle: DiffStyleType.WORD +}; +var separator = "/"; +var distance = newDistanceFn(function(change) { + return change.value; +}); +var matcher = newMatcherFn(distance); +function isDevNullName(name) { + return name.indexOf("dev/null") !== -1; +} +function removeInsElements(line) { + return line.replace(/(]*>((.|\n)*?)<\/ins>)/g, ""); +} +function removeDelElements(line) { + return line.replace(/(]*>((.|\n)*?)<\/del>)/g, ""); +} +function toCSSClass(lineType) { + switch (lineType) { + case LineType.CONTEXT: + return CSSLineClass.CONTEXT; + case LineType.INSERT: + return CSSLineClass.INSERTS; + case LineType.DELETE: + return CSSLineClass.DELETES; + } +} +function prefixLength(isCombined) { + return isCombined ? 2 : 1; +} +function escapeForHtml(str) { + return str.slice(0).replace(/&/g, "&").replace(//g, ">").replace(/"/g, """).replace(/'/g, "'").replace(/\//g, "/"); +} +function deconstructLine(line, isCombined, escape) { + if (escape === void 0) { + escape = true; + } + var indexToSplit = prefixLength(isCombined); + return { + prefix: line.substring(0, indexToSplit), + content: escape ? escapeForHtml(line.substring(indexToSplit)) : line.substring(indexToSplit) + }; +} +function filenameDiff(file) { + var oldFilename = unifyPath(file.oldName); + var newFilename = unifyPath(file.newName); + if (oldFilename !== newFilename && !isDevNullName(oldFilename) && !isDevNullName(newFilename)) { + var prefixPaths = []; + var suffixPaths = []; + var oldFilenameParts = oldFilename.split(separator); + var newFilenameParts = newFilename.split(separator); + var oldFilenamePartsSize = oldFilenameParts.length; + var newFilenamePartsSize = newFilenameParts.length; + var i = 0; + var j = oldFilenamePartsSize - 1; + var k = newFilenamePartsSize - 1; + while (i < j && i < k) { + if (oldFilenameParts[i] === newFilenameParts[i]) { + prefixPaths.push(newFilenameParts[i]); + i += 1; + } else { + break; + } + } + while (j > i && k > i) { + if (oldFilenameParts[j] === newFilenameParts[k]) { + suffixPaths.unshift(newFilenameParts[k]); + j -= 1; + k -= 1; + } else { + break; + } + } + var finalPrefix = prefixPaths.join(separator); + var finalSuffix = suffixPaths.join(separator); + var oldRemainingPath = oldFilenameParts.slice(i, j + 1).join(separator); + var newRemainingPath = newFilenameParts.slice(i, k + 1).join(separator); + if (finalPrefix.length && finalSuffix.length) { + return finalPrefix + separator + "{" + oldRemainingPath + " \u2192 " + newRemainingPath + "}" + separator + finalSuffix; + } else if (finalPrefix.length) { + return finalPrefix + separator + "{" + oldRemainingPath + " \u2192 " + newRemainingPath + "}"; + } else if (finalSuffix.length) { + return "{" + oldRemainingPath + " \u2192 " + newRemainingPath + "}" + separator + finalSuffix; + } + return oldFilename + " \u2192 " + newFilename; + } else if (!isDevNullName(newFilename)) { + return newFilename; + } else { + return oldFilename; + } +} +function getHtmlId(file) { + return "d2h-".concat(hashCode(filenameDiff(file)).toString().slice(-6)); +} +function getFileIcon(file) { + var templateName = "file-changed"; + if (file.isRename) { + templateName = "file-renamed"; + } else if (file.isCopy) { + templateName = "file-renamed"; + } else if (file.isNew) { + templateName = "file-added"; + } else if (file.isDeleted) { + templateName = "file-deleted"; + } else if (file.newName !== file.oldName) { + templateName = "file-renamed"; + } + return templateName; +} +function diffHighlight(diffLine1, diffLine2, isCombined, config) { + if (config === void 0) { + config = {}; + } + var _a2 = __assign(__assign({}, defaultRenderConfig), config), matching = _a2.matching, maxLineLengthHighlight = _a2.maxLineLengthHighlight, matchWordsThreshold = _a2.matchWordsThreshold, diffStyle = _a2.diffStyle; + var line1 = deconstructLine(diffLine1, isCombined, false); + var line2 = deconstructLine(diffLine2, isCombined, false); + if (line1.content.length > maxLineLengthHighlight || line2.content.length > maxLineLengthHighlight) { + return { + oldLine: { + prefix: line1.prefix, + content: escapeForHtml(line1.content) + }, + newLine: { + prefix: line2.prefix, + content: escapeForHtml(line2.content) + } + }; + } + var diff2 = diffStyle === "char" ? diffChars(line1.content, line2.content) : diffWordsWithSpace(line1.content, line2.content); + var changedWords = []; + if (diffStyle === "word" && matching === "words") { + var removed = diff2.filter(function(element2) { + return element2.removed; + }); + var added = diff2.filter(function(element2) { + return element2.added; + }); + var chunks = matcher(added, removed); + chunks.forEach(function(chunk) { + if (chunk[0].length === 1 && chunk[1].length === 1) { + var dist = distance(chunk[0][0], chunk[1][0]); + if (dist < matchWordsThreshold) { + changedWords.push(chunk[0][0]); + changedWords.push(chunk[1][0]); + } + } + }); + } + var highlightedLine = diff2.reduce(function(highlightedLine2, part) { + var elemType = part.added ? "ins" : part.removed ? "del" : null; + var addClass = changedWords.indexOf(part) > -1 ? ' class="d2h-change"' : ""; + var escapedValue = escapeForHtml(part.value); + return elemType !== null ? "".concat(highlightedLine2, "<").concat(elemType).concat(addClass, ">").concat(escapedValue, "") : "".concat(highlightedLine2).concat(escapedValue); + }, ""); + return { + oldLine: { + prefix: line1.prefix, + content: removeInsElements(highlightedLine) + }, + newLine: { + prefix: line2.prefix, + content: removeDelElements(highlightedLine) + } + }; +} + +// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/file-list-renderer.js +var baseTemplatesPath = "file-summary"; +var iconsBaseTemplatesPath = "icon"; +function render(diffFiles, hoganUtils) { + var files = diffFiles.map(function(file) { + return hoganUtils.render(baseTemplatesPath, "line", { + fileHtmlId: getHtmlId(file), + oldName: file.oldName, + newName: file.newName, + fileName: filenameDiff(file), + deletedLines: "-" + file.deletedLines, + addedLines: "+" + file.addedLines + }, { + fileIcon: hoganUtils.template(iconsBaseTemplatesPath, getFileIcon(file)) + }); + }).join("\n"); + return hoganUtils.render(baseTemplatesPath, "wrapper", { + filesNumber: diffFiles.length, + files + }); +} + +// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/line-by-line-renderer.js +init_polyfill_buffer(); +var __assign2 = function() { + __assign2 = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) + if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign2.apply(this, arguments); +}; +var defaultLineByLineRendererConfig = __assign2(__assign2({}, defaultRenderConfig), { renderNothingWhenEmpty: false, matchingMaxComparisons: 2500, maxLineSizeInBlockForComparison: 200 }); +var genericTemplatesPath = "generic"; +var baseTemplatesPath2 = "line-by-line"; +var iconsBaseTemplatesPath2 = "icon"; +var tagsBaseTemplatesPath = "tag"; +var LineByLineRenderer = function() { + function LineByLineRenderer2(hoganUtils, config) { + if (config === void 0) { + config = {}; + } + this.hoganUtils = hoganUtils; + this.config = __assign2(__assign2({}, defaultLineByLineRendererConfig), config); + } + LineByLineRenderer2.prototype.render = function(diffFiles) { + var _this = this; + var diffsHtml = diffFiles.map(function(file) { + var diffs; + if (file.blocks.length) { + diffs = _this.generateFileHtml(file); + } else { + diffs = _this.generateEmptyDiff(); + } + return _this.makeFileDiffHtml(file, diffs); + }).join("\n"); + return this.hoganUtils.render(genericTemplatesPath, "wrapper", { content: diffsHtml }); + }; + LineByLineRenderer2.prototype.makeFileDiffHtml = function(file, diffs) { + if (this.config.renderNothingWhenEmpty && Array.isArray(file.blocks) && file.blocks.length === 0) + return ""; + var fileDiffTemplate = this.hoganUtils.template(baseTemplatesPath2, "file-diff"); + var filePathTemplate = this.hoganUtils.template(genericTemplatesPath, "file-path"); + var fileIconTemplate = this.hoganUtils.template(iconsBaseTemplatesPath2, "file"); + var fileTagTemplate = this.hoganUtils.template(tagsBaseTemplatesPath, getFileIcon(file)); + return fileDiffTemplate.render({ + file, + fileHtmlId: getHtmlId(file), + diffs, + filePath: filePathTemplate.render({ + fileDiffName: filenameDiff(file) + }, { + fileIcon: fileIconTemplate, + fileTag: fileTagTemplate + }) + }); + }; + LineByLineRenderer2.prototype.generateEmptyDiff = function() { + return this.hoganUtils.render(genericTemplatesPath, "empty-diff", { + contentClass: "d2h-code-line", + CSSLineClass + }); + }; + LineByLineRenderer2.prototype.generateFileHtml = function(file) { + var _this = this; + var matcher2 = newMatcherFn(newDistanceFn(function(e) { + return deconstructLine(e.content, file.isCombined).content; + })); + return file.blocks.map(function(block) { + var lines = _this.hoganUtils.render(genericTemplatesPath, "block-header", { + CSSLineClass, + blockHeader: file.isTooBig ? block.header : escapeForHtml(block.header), + lineClass: "d2h-code-linenumber", + contentClass: "d2h-code-line" + }); + _this.applyLineGroupping(block).forEach(function(_a2) { + var contextLines = _a2[0], oldLines = _a2[1], newLines = _a2[2]; + if (oldLines.length && newLines.length && !contextLines.length) { + _this.applyRematchMatching(oldLines, newLines, matcher2).map(function(_a3) { + var oldLines2 = _a3[0], newLines2 = _a3[1]; + var _b2 = _this.processChangedLines(file, file.isCombined, oldLines2, newLines2), left2 = _b2.left, right2 = _b2.right; + lines += left2; + lines += right2; + }); + } else if (contextLines.length) { + contextLines.forEach(function(line) { + var _a3 = deconstructLine(line.content, file.isCombined), prefix = _a3.prefix, content = _a3.content; + lines += _this.generateSingleLineHtml(file, { + type: CSSLineClass.CONTEXT, + prefix, + content, + oldNumber: line.oldNumber, + newNumber: line.newNumber + }); + }); + } else if (oldLines.length || newLines.length) { + var _b = _this.processChangedLines(file, file.isCombined, oldLines, newLines), left = _b.left, right = _b.right; + lines += left; + lines += right; + } else { + console.error("Unknown state reached while processing groups of lines", contextLines, oldLines, newLines); + } + }); + return lines; + }).join("\n"); + }; + LineByLineRenderer2.prototype.applyLineGroupping = function(block) { + var blockLinesGroups = []; + var oldLines = []; + var newLines = []; + for (var i = 0; i < block.lines.length; i++) { + var diffLine = block.lines[i]; + if (diffLine.type !== LineType.INSERT && newLines.length || diffLine.type === LineType.CONTEXT && oldLines.length > 0) { + blockLinesGroups.push([[], oldLines, newLines]); + oldLines = []; + newLines = []; + } + if (diffLine.type === LineType.CONTEXT) { + blockLinesGroups.push([[diffLine], [], []]); + } else if (diffLine.type === LineType.INSERT && oldLines.length === 0) { + blockLinesGroups.push([[], [], [diffLine]]); + } else if (diffLine.type === LineType.INSERT && oldLines.length > 0) { + newLines.push(diffLine); + } else if (diffLine.type === LineType.DELETE) { + oldLines.push(diffLine); + } + } + if (oldLines.length || newLines.length) { + blockLinesGroups.push([[], oldLines, newLines]); + oldLines = []; + newLines = []; + } + return blockLinesGroups; + }; + LineByLineRenderer2.prototype.applyRematchMatching = function(oldLines, newLines, matcher2) { + var comparisons = oldLines.length * newLines.length; + var maxLineSizeInBlock = Math.max.apply(null, [0].concat(oldLines.concat(newLines).map(function(elem) { + return elem.content.length; + }))); + var doMatching = comparisons < this.config.matchingMaxComparisons && maxLineSizeInBlock < this.config.maxLineSizeInBlockForComparison && (this.config.matching === "lines" || this.config.matching === "words"); + return doMatching ? matcher2(oldLines, newLines) : [[oldLines, newLines]]; + }; + LineByLineRenderer2.prototype.processChangedLines = function(file, isCombined, oldLines, newLines) { + var fileHtml = { + right: "", + left: "" + }; + var maxLinesNumber = Math.max(oldLines.length, newLines.length); + for (var i = 0; i < maxLinesNumber; i++) { + var oldLine = oldLines[i]; + var newLine = newLines[i]; + var diff2 = oldLine !== void 0 && newLine !== void 0 ? diffHighlight(oldLine.content, newLine.content, isCombined, this.config) : void 0; + var preparedOldLine = oldLine !== void 0 && oldLine.oldNumber !== void 0 ? __assign2(__assign2({}, diff2 !== void 0 ? { + prefix: diff2.oldLine.prefix, + content: diff2.oldLine.content, + type: CSSLineClass.DELETE_CHANGES + } : __assign2(__assign2({}, deconstructLine(oldLine.content, isCombined)), { type: toCSSClass(oldLine.type) })), { oldNumber: oldLine.oldNumber, newNumber: oldLine.newNumber }) : void 0; + var preparedNewLine = newLine !== void 0 && newLine.newNumber !== void 0 ? __assign2(__assign2({}, diff2 !== void 0 ? { + prefix: diff2.newLine.prefix, + content: diff2.newLine.content, + type: CSSLineClass.INSERT_CHANGES + } : __assign2(__assign2({}, deconstructLine(newLine.content, isCombined)), { type: toCSSClass(newLine.type) })), { oldNumber: newLine.oldNumber, newNumber: newLine.newNumber }) : void 0; + var _a2 = this.generateLineHtml(file, preparedOldLine, preparedNewLine), left = _a2.left, right = _a2.right; + fileHtml.left += left; + fileHtml.right += right; + } + return fileHtml; + }; + LineByLineRenderer2.prototype.generateLineHtml = function(file, oldLine, newLine) { + return { + left: this.generateSingleLineHtml(file, oldLine), + right: this.generateSingleLineHtml(file, newLine) + }; + }; + LineByLineRenderer2.prototype.generateSingleLineHtml = function(file, line) { + if (line === void 0) + return ""; + var lineNumberHtml = this.hoganUtils.render(baseTemplatesPath2, "numbers", { + oldNumber: line.oldNumber || "", + newNumber: line.newNumber || "" + }); + return this.hoganUtils.render(genericTemplatesPath, "line", { + type: line.type, + lineClass: "d2h-code-linenumber", + contentClass: "d2h-code-line", + prefix: line.prefix === " " ? " " : line.prefix, + content: line.content, + lineNumber: lineNumberHtml, + line, + file + }); + }; + return LineByLineRenderer2; +}(); +var line_by_line_renderer_default = LineByLineRenderer; + +// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/side-by-side-renderer.js +init_polyfill_buffer(); +var __assign3 = function() { + __assign3 = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) + if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign3.apply(this, arguments); +}; +var defaultSideBySideRendererConfig = __assign3(__assign3({}, defaultRenderConfig), { renderNothingWhenEmpty: false, matchingMaxComparisons: 2500, maxLineSizeInBlockForComparison: 200 }); +var genericTemplatesPath2 = "generic"; +var baseTemplatesPath3 = "side-by-side"; +var iconsBaseTemplatesPath3 = "icon"; +var tagsBaseTemplatesPath2 = "tag"; +var SideBySideRenderer = function() { + function SideBySideRenderer2(hoganUtils, config) { + if (config === void 0) { + config = {}; + } + this.hoganUtils = hoganUtils; + this.config = __assign3(__assign3({}, defaultSideBySideRendererConfig), config); + } + SideBySideRenderer2.prototype.render = function(diffFiles) { + var _this = this; + var diffsHtml = diffFiles.map(function(file) { + var diffs; + if (file.blocks.length) { + diffs = _this.generateFileHtml(file); + } else { + diffs = _this.generateEmptyDiff(); + } + return _this.makeFileDiffHtml(file, diffs); + }).join("\n"); + return this.hoganUtils.render(genericTemplatesPath2, "wrapper", { content: diffsHtml }); + }; + SideBySideRenderer2.prototype.makeFileDiffHtml = function(file, diffs) { + if (this.config.renderNothingWhenEmpty && Array.isArray(file.blocks) && file.blocks.length === 0) + return ""; + var fileDiffTemplate = this.hoganUtils.template(baseTemplatesPath3, "file-diff"); + var filePathTemplate = this.hoganUtils.template(genericTemplatesPath2, "file-path"); + var fileIconTemplate = this.hoganUtils.template(iconsBaseTemplatesPath3, "file"); + var fileTagTemplate = this.hoganUtils.template(tagsBaseTemplatesPath2, getFileIcon(file)); + return fileDiffTemplate.render({ + file, + fileHtmlId: getHtmlId(file), + diffs, + filePath: filePathTemplate.render({ + fileDiffName: filenameDiff(file) + }, { + fileIcon: fileIconTemplate, + fileTag: fileTagTemplate + }) + }); + }; + SideBySideRenderer2.prototype.generateEmptyDiff = function() { + return { + right: "", + left: this.hoganUtils.render(genericTemplatesPath2, "empty-diff", { + contentClass: "d2h-code-side-line", + CSSLineClass + }) + }; + }; + SideBySideRenderer2.prototype.generateFileHtml = function(file) { + var _this = this; + var matcher2 = newMatcherFn(newDistanceFn(function(e) { + return deconstructLine(e.content, file.isCombined).content; + })); + return file.blocks.map(function(block) { + var fileHtml = { + left: _this.makeHeaderHtml(block.header, file), + right: _this.makeHeaderHtml("") + }; + _this.applyLineGroupping(block).forEach(function(_a2) { + var contextLines = _a2[0], oldLines = _a2[1], newLines = _a2[2]; + if (oldLines.length && newLines.length && !contextLines.length) { + _this.applyRematchMatching(oldLines, newLines, matcher2).map(function(_a3) { + var oldLines2 = _a3[0], newLines2 = _a3[1]; + var _b2 = _this.processChangedLines(file.isCombined, oldLines2, newLines2), left2 = _b2.left, right2 = _b2.right; + fileHtml.left += left2; + fileHtml.right += right2; + }); + } else if (contextLines.length) { + contextLines.forEach(function(line) { + var _a3 = deconstructLine(line.content, file.isCombined), prefix = _a3.prefix, content = _a3.content; + var _b2 = _this.generateLineHtml({ + type: CSSLineClass.CONTEXT, + prefix, + content, + number: line.oldNumber + }, { + type: CSSLineClass.CONTEXT, + prefix, + content, + number: line.newNumber + }), left2 = _b2.left, right2 = _b2.right; + fileHtml.left += left2; + fileHtml.right += right2; + }); + } else if (oldLines.length || newLines.length) { + var _b = _this.processChangedLines(file.isCombined, oldLines, newLines), left = _b.left, right = _b.right; + fileHtml.left += left; + fileHtml.right += right; + } else { + console.error("Unknown state reached while processing groups of lines", contextLines, oldLines, newLines); + } + }); + return fileHtml; + }).reduce(function(accomulated, html2) { + return { left: accomulated.left + html2.left, right: accomulated.right + html2.right }; + }, { left: "", right: "" }); + }; + SideBySideRenderer2.prototype.applyLineGroupping = function(block) { + var blockLinesGroups = []; + var oldLines = []; + var newLines = []; + for (var i = 0; i < block.lines.length; i++) { + var diffLine = block.lines[i]; + if (diffLine.type !== LineType.INSERT && newLines.length || diffLine.type === LineType.CONTEXT && oldLines.length > 0) { + blockLinesGroups.push([[], oldLines, newLines]); + oldLines = []; + newLines = []; + } + if (diffLine.type === LineType.CONTEXT) { + blockLinesGroups.push([[diffLine], [], []]); + } else if (diffLine.type === LineType.INSERT && oldLines.length === 0) { + blockLinesGroups.push([[], [], [diffLine]]); + } else if (diffLine.type === LineType.INSERT && oldLines.length > 0) { + newLines.push(diffLine); + } else if (diffLine.type === LineType.DELETE) { + oldLines.push(diffLine); + } + } + if (oldLines.length || newLines.length) { + blockLinesGroups.push([[], oldLines, newLines]); + oldLines = []; + newLines = []; + } + return blockLinesGroups; + }; + SideBySideRenderer2.prototype.applyRematchMatching = function(oldLines, newLines, matcher2) { + var comparisons = oldLines.length * newLines.length; + var maxLineSizeInBlock = Math.max.apply(null, [0].concat(oldLines.concat(newLines).map(function(elem) { + return elem.content.length; + }))); + var doMatching = comparisons < this.config.matchingMaxComparisons && maxLineSizeInBlock < this.config.maxLineSizeInBlockForComparison && (this.config.matching === "lines" || this.config.matching === "words"); + return doMatching ? matcher2(oldLines, newLines) : [[oldLines, newLines]]; + }; + SideBySideRenderer2.prototype.makeHeaderHtml = function(blockHeader, file) { + return this.hoganUtils.render(genericTemplatesPath2, "block-header", { + CSSLineClass, + blockHeader: (file === null || file === void 0 ? void 0 : file.isTooBig) ? blockHeader : escapeForHtml(blockHeader), + lineClass: "d2h-code-side-linenumber", + contentClass: "d2h-code-side-line" + }); + }; + SideBySideRenderer2.prototype.processChangedLines = function(isCombined, oldLines, newLines) { + var fileHtml = { + right: "", + left: "" + }; + var maxLinesNumber = Math.max(oldLines.length, newLines.length); + for (var i = 0; i < maxLinesNumber; i++) { + var oldLine = oldLines[i]; + var newLine = newLines[i]; + var diff2 = oldLine !== void 0 && newLine !== void 0 ? diffHighlight(oldLine.content, newLine.content, isCombined, this.config) : void 0; + var preparedOldLine = oldLine !== void 0 && oldLine.oldNumber !== void 0 ? __assign3(__assign3({}, diff2 !== void 0 ? { + prefix: diff2.oldLine.prefix, + content: diff2.oldLine.content, + type: CSSLineClass.DELETE_CHANGES + } : __assign3(__assign3({}, deconstructLine(oldLine.content, isCombined)), { type: toCSSClass(oldLine.type) })), { number: oldLine.oldNumber }) : void 0; + var preparedNewLine = newLine !== void 0 && newLine.newNumber !== void 0 ? __assign3(__assign3({}, diff2 !== void 0 ? { + prefix: diff2.newLine.prefix, + content: diff2.newLine.content, + type: CSSLineClass.INSERT_CHANGES + } : __assign3(__assign3({}, deconstructLine(newLine.content, isCombined)), { type: toCSSClass(newLine.type) })), { number: newLine.newNumber }) : void 0; + var _a2 = this.generateLineHtml(preparedOldLine, preparedNewLine), left = _a2.left, right = _a2.right; + fileHtml.left += left; + fileHtml.right += right; + } + return fileHtml; + }; + SideBySideRenderer2.prototype.generateLineHtml = function(oldLine, newLine) { + return { + left: this.generateSingleHtml(oldLine), + right: this.generateSingleHtml(newLine) + }; + }; + SideBySideRenderer2.prototype.generateSingleHtml = function(line) { + var lineClass = "d2h-code-side-linenumber"; + var contentClass = "d2h-code-side-line"; + return this.hoganUtils.render(genericTemplatesPath2, "line", { + type: (line === null || line === void 0 ? void 0 : line.type) || "".concat(CSSLineClass.CONTEXT, " d2h-emptyplaceholder"), + lineClass: line !== void 0 ? lineClass : "".concat(lineClass, " d2h-code-side-emptyplaceholder"), + contentClass: line !== void 0 ? contentClass : "".concat(contentClass, " d2h-code-side-emptyplaceholder"), + prefix: (line === null || line === void 0 ? void 0 : line.prefix) === " " ? " " : line === null || line === void 0 ? void 0 : line.prefix, + content: line === null || line === void 0 ? void 0 : line.content, + lineNumber: line === null || line === void 0 ? void 0 : line.number + }); + }; + return SideBySideRenderer2; +}(); +var side_by_side_renderer_default = SideBySideRenderer; + +// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/hoganjs-utils.js +init_polyfill_buffer(); +var Hogan3 = __toESM(require_hogan()); + +// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/diff2html-templates.js +init_polyfill_buffer(); +var Hogan2 = __toESM(require_hogan()); +var defaultTemplates = {}; +defaultTemplates["file-summary-line"] = new Hogan2.Template({ code: function(c, p, i) { + var t = this; + t.b(i = i || ""); + t.b('
  • '); + t.b("\n" + i); + t.b(' '); + t.b("\n" + i); + t.b(t.rp("'); + t.b(t.v(t.f("fileName", c, p, 0))); + t.b(""); + t.b("\n" + i); + t.b(' '); + t.b("\n" + i); + t.b(' '); + t.b(t.v(t.f("addedLines", c, p, 0))); + t.b(""); + t.b("\n" + i); + t.b(' '); + t.b(t.v(t.f("deletedLines", c, p, 0))); + t.b(""); + t.b("\n" + i); + t.b(" "); + t.b("\n" + i); + t.b(" "); + t.b("\n" + i); + t.b("
    • "); + return t.fl(); +}, partials: { "'); + t.b("\n" + i); + t.b('
    '); + t.b("\n" + i); + t.b(' Files changed ('); + t.b(t.v(t.f("filesNumber", c, p, 0))); + t.b(")"); + t.b("\n" + i); + t.b(' hide'); + t.b("\n" + i); + t.b(' show'); + t.b("\n" + i); + t.b("
    "); + t.b("\n" + i); + t.b('
      '); + t.b("\n" + i); + t.b(" "); + t.b(t.t(t.f("files", c, p, 0))); + t.b("\n" + i); + t.b("
    "); + t.b("\n" + i); + t.b(""); + return t.fl(); +}, partials: {}, subs: {} }); +defaultTemplates["generic-block-header"] = new Hogan2.Template({ code: function(c, p, i) { + var t = this; + t.b(i = i || ""); + t.b(""); + t.b("\n" + i); + t.b(' '); + t.b("\n" + i); + t.b(' '); + t.b("\n" + i); + t.b('
    '); + if (t.s(t.f("blockHeader", c, p, 1), c, p, 0, 156, 173, "{{ }}")) { + t.rs(c, p, function(c2, p2, t2) { + t2.b(t2.t(t2.f("blockHeader", c2, p2, 0))); + }); + c.pop(); + } + if (!t.s(t.f("blockHeader", c, p, 1), c, p, 1, 0, 0, "")) { + t.b(" "); + } + ; + t.b("
    "); + t.b("\n" + i); + t.b(" "); + t.b("\n" + i); + t.b(""); + return t.fl(); +}, partials: {}, subs: {} }); +defaultTemplates["generic-empty-diff"] = new Hogan2.Template({ code: function(c, p, i) { + var t = this; + t.b(i = i || ""); + t.b(""); + t.b("\n" + i); + t.b(' '); + t.b("\n" + i); + t.b('
    '); + t.b("\n" + i); + t.b(" File without changes"); + t.b("\n" + i); + t.b("
    "); + t.b("\n" + i); + t.b(" "); + t.b("\n" + i); + t.b(""); + return t.fl(); +}, partials: {}, subs: {} }); +defaultTemplates["generic-file-path"] = new Hogan2.Template({ code: function(c, p, i) { + var t = this; + t.b(i = i || ""); + t.b(''); + t.b("\n" + i); + t.b(t.rp("'); + t.b(t.v(t.f("fileDiffName", c, p, 0))); + t.b(""); + t.b("\n" + i); + t.b(t.rp(""); + t.b("\n" + i); + t.b('"); + return t.fl(); +}, partials: { ""); + t.b("\n" + i); + t.b(' '); + t.b("\n" + i); + t.b(" "); + t.b(t.t(t.f("lineNumber", c, p, 0))); + t.b("\n" + i); + t.b(" "); + t.b("\n" + i); + t.b(' '); + t.b("\n" + i); + t.b('
    '); + t.b("\n" + i); + if (t.s(t.f("prefix", c, p, 1), c, p, 0, 162, 238, "{{ }}")) { + t.rs(c, p, function(c2, p2, t2) { + t2.b(' '); + t2.b(t2.t(t2.f("prefix", c2, p2, 0))); + t2.b(""); + t2.b("\n" + i); + }); + c.pop(); + } + if (!t.s(t.f("prefix", c, p, 1), c, p, 1, 0, 0, "")) { + t.b('  '); + t.b("\n" + i); + } + ; + if (t.s(t.f("content", c, p, 1), c, p, 0, 371, 445, "{{ }}")) { + t.rs(c, p, function(c2, p2, t2) { + t2.b(' '); + t2.b(t2.t(t2.f("content", c2, p2, 0))); + t2.b(""); + t2.b("\n" + i); + }); + c.pop(); + } + if (!t.s(t.f("content", c, p, 1), c, p, 1, 0, 0, "")) { + t.b('
    '); + t.b("\n" + i); + } + ; + t.b("
    "); + t.b("\n" + i); + t.b(" "); + t.b("\n" + i); + t.b(""); + return t.fl(); +}, partials: {}, subs: {} }); +defaultTemplates["generic-wrapper"] = new Hogan2.Template({ code: function(c, p, i) { + var t = this; + t.b(i = i || ""); + t.b('
    '); + t.b("\n" + i); + t.b(" "); + t.b(t.t(t.f("content", c, p, 0))); + t.b("\n" + i); + t.b("
    "); + return t.fl(); +}, partials: {}, subs: {} }); +defaultTemplates["icon-file-added"] = new Hogan2.Template({ code: function(c, p, i) { + var t = this; + t.b(i = i || ""); + t.b('"); + return t.fl(); +}, partials: {}, subs: {} }); +defaultTemplates["icon-file-changed"] = new Hogan2.Template({ code: function(c, p, i) { + var t = this; + t.b(i = i || ""); + t.b('"); + return t.fl(); +}, partials: {}, subs: {} }); +defaultTemplates["icon-file-deleted"] = new Hogan2.Template({ code: function(c, p, i) { + var t = this; + t.b(i = i || ""); + t.b('"); + return t.fl(); +}, partials: {}, subs: {} }); +defaultTemplates["icon-file-renamed"] = new Hogan2.Template({ code: function(c, p, i) { + var t = this; + t.b(i = i || ""); + t.b('"); + return t.fl(); +}, partials: {}, subs: {} }); +defaultTemplates["icon-file"] = new Hogan2.Template({ code: function(c, p, i) { + var t = this; + t.b(i = i || ""); + t.b('"); + return t.fl(); +}, partials: {}, subs: {} }); +defaultTemplates["line-by-line-file-diff"] = new Hogan2.Template({ code: function(c, p, i) { + var t = this; + t.b(i = i || ""); + t.b('
    '); + t.b("\n" + i); + t.b('
    '); + t.b("\n" + i); + t.b(" "); + t.b(t.t(t.f("filePath", c, p, 0))); + t.b("\n" + i); + t.b("
    "); + t.b("\n" + i); + t.b('
    '); + t.b("\n" + i); + t.b('
    '); + t.b("\n" + i); + t.b(' '); + t.b("\n" + i); + t.b(' '); + t.b("\n" + i); + t.b(" "); + t.b(t.t(t.f("diffs", c, p, 0))); + t.b("\n" + i); + t.b(" "); + t.b("\n" + i); + t.b("
    "); + t.b("\n" + i); + t.b("
    "); + t.b("\n" + i); + t.b("
    "); + t.b("\n" + i); + t.b("
    "); + return t.fl(); +}, partials: {}, subs: {} }); +defaultTemplates["line-by-line-numbers"] = new Hogan2.Template({ code: function(c, p, i) { + var t = this; + t.b(i = i || ""); + t.b('
    '); + t.b(t.v(t.f("oldNumber", c, p, 0))); + t.b("
    "); + t.b("\n" + i); + t.b('
    '); + t.b(t.v(t.f("newNumber", c, p, 0))); + t.b("
    "); + return t.fl(); +}, partials: {}, subs: {} }); +defaultTemplates["side-by-side-file-diff"] = new Hogan2.Template({ code: function(c, p, i) { + var t = this; + t.b(i = i || ""); + t.b('
    '); + t.b("\n" + i); + t.b('
    '); + t.b("\n" + i); + t.b(" "); + t.b(t.t(t.f("filePath", c, p, 0))); + t.b("\n" + i); + t.b("
    "); + t.b("\n" + i); + t.b('
    '); + t.b("\n" + i); + t.b('
    '); + t.b("\n" + i); + t.b('
    '); + t.b("\n" + i); + t.b(' '); + t.b("\n" + i); + t.b(' '); + t.b("\n" + i); + t.b(" "); + t.b(t.t(t.d("diffs.left", c, p, 0))); + t.b("\n" + i); + t.b(" "); + t.b("\n" + i); + t.b("
    "); + t.b("\n" + i); + t.b("
    "); + t.b("\n" + i); + t.b("
    "); + t.b("\n" + i); + t.b('
    '); + t.b("\n" + i); + t.b('
    '); + t.b("\n" + i); + t.b(' '); + t.b("\n" + i); + t.b(' '); + t.b("\n" + i); + t.b(" "); + t.b(t.t(t.d("diffs.right", c, p, 0))); + t.b("\n" + i); + t.b(" "); + t.b("\n" + i); + t.b("
    "); + t.b("\n" + i); + t.b("
    "); + t.b("\n" + i); + t.b("
    "); + t.b("\n" + i); + t.b("
    "); + t.b("\n" + i); + t.b("
    "); + return t.fl(); +}, partials: {}, subs: {} }); +defaultTemplates["tag-file-added"] = new Hogan2.Template({ code: function(c, p, i) { + var t = this; + t.b(i = i || ""); + t.b('ADDED'); + return t.fl(); +}, partials: {}, subs: {} }); +defaultTemplates["tag-file-changed"] = new Hogan2.Template({ code: function(c, p, i) { + var t = this; + t.b(i = i || ""); + t.b('CHANGED'); + return t.fl(); +}, partials: {}, subs: {} }); +defaultTemplates["tag-file-deleted"] = new Hogan2.Template({ code: function(c, p, i) { + var t = this; + t.b(i = i || ""); + t.b('DELETED'); + return t.fl(); +}, partials: {}, subs: {} }); +defaultTemplates["tag-file-renamed"] = new Hogan2.Template({ code: function(c, p, i) { + var t = this; + t.b(i = i || ""); + t.b('RENAMED'); + return t.fl(); +}, partials: {}, subs: {} }); + +// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/hoganjs-utils.js +var __assign4 = function() { + __assign4 = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) + if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign4.apply(this, arguments); +}; +var HoganJsUtils = function() { + function HoganJsUtils2(_a2) { + var _b = _a2.compiledTemplates, compiledTemplates = _b === void 0 ? {} : _b, _c = _a2.rawTemplates, rawTemplates = _c === void 0 ? {} : _c; + var compiledRawTemplates = Object.entries(rawTemplates).reduce(function(previousTemplates, _a3) { + var _b2; + var name = _a3[0], templateString = _a3[1]; + var compiledTemplate = Hogan3.compile(templateString, { asString: false }); + return __assign4(__assign4({}, previousTemplates), (_b2 = {}, _b2[name] = compiledTemplate, _b2)); + }, {}); + this.preCompiledTemplates = __assign4(__assign4(__assign4({}, defaultTemplates), compiledTemplates), compiledRawTemplates); + } + HoganJsUtils2.compile = function(templateString) { + return Hogan3.compile(templateString, { asString: false }); + }; + HoganJsUtils2.prototype.render = function(namespace, view, params, partials, indent2) { + var templateKey = this.templateKey(namespace, view); + try { + var template = this.preCompiledTemplates[templateKey]; + return template.render(params, partials, indent2); + } catch (e) { + throw new Error("Could not find template to render '".concat(templateKey, "'")); + } + }; + HoganJsUtils2.prototype.template = function(namespace, view) { + return this.preCompiledTemplates[this.templateKey(namespace, view)]; + }; + HoganJsUtils2.prototype.templateKey = function(namespace, view) { + return "".concat(namespace, "-").concat(view); + }; + return HoganJsUtils2; +}(); +var hoganjs_utils_default = HoganJsUtils; + +// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/diff2html.js +var __assign5 = function() { + __assign5 = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) + if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign5.apply(this, arguments); +}; +var defaultDiff2HtmlConfig = __assign5(__assign5(__assign5({}, defaultLineByLineRendererConfig), defaultSideBySideRendererConfig), { outputFormat: OutputFormatType.LINE_BY_LINE, drawFileList: true }); +function html(diffInput, configuration) { + if (configuration === void 0) { + configuration = {}; + } + var config = __assign5(__assign5({}, defaultDiff2HtmlConfig), configuration); + var diffJson = typeof diffInput === "string" ? parse(diffInput, config) : diffInput; + var hoganUtils = new hoganjs_utils_default(config); + var fileList = config.drawFileList ? render(diffJson, hoganUtils) : ""; + var diffOutput = config.outputFormat === "side-by-side" ? new side_by_side_renderer_default(hoganUtils, config).render(diffJson) : new line_by_line_renderer_default(hoganUtils, config).render(diffJson); + return fileList + diffOutput; +} + +// src/ui/diff/diffView.ts +var import_obsidian17 = require("obsidian"); +var DiffView = class extends import_obsidian17.ItemView { + constructor(leaf, plugin) { + super(leaf); + this.plugin = plugin; + this.gettingDiff = false; + this.gitRefreshBind = this.refresh.bind(this); + this.gitViewRefreshBind = this.refresh.bind(this); + this.parser = new DOMParser(); + this.navigation = true; + addEventListener("git-refresh", this.gitRefreshBind); + addEventListener("git-view-refresh", this.gitViewRefreshBind); + } + getViewType() { + return DIFF_VIEW_CONFIG.type; + } + getDisplayText() { + var _a2; + if (((_a2 = this.state) == null ? void 0 : _a2.file) != null) { + let fileName = this.state.file.split("/").last(); + if (fileName == null ? void 0 : fileName.endsWith(".md")) + fileName = fileName.slice(0, -3); + return DIFF_VIEW_CONFIG.name + ` (${fileName})`; + } + return DIFF_VIEW_CONFIG.name; + } + getIcon() { + return DIFF_VIEW_CONFIG.icon; + } + async setState(state, result) { + this.state = state; + await this.refresh(); + return; + } + getState() { + return this.state; + } + onClose() { + removeEventListener("git-refresh", this.gitRefreshBind); + removeEventListener("git-view-refresh", this.gitViewRefreshBind); + return super.onClose(); + } + onOpen() { + this.refresh(); + return super.onOpen(); + } + async refresh() { + var _a2; + if (((_a2 = this.state) == null ? void 0 : _a2.file) && !this.gettingDiff && this.plugin.gitManager) { + this.gettingDiff = true; + try { + let diff2 = await this.plugin.gitManager.getDiffString( + this.state.file, + this.state.staged, + this.state.hash + ); + this.contentEl.empty(); + if (!diff2) { + if (this.plugin.gitManager instanceof SimpleGit && await this.plugin.gitManager.isTracked( + this.state.file + )) { + diff2 = [ + `--- ${this.state.file}`, + `+++ ${this.state.file}`, + "" + ].join("\n"); + } else { + const content = await this.app.vault.adapter.read( + this.plugin.gitManager.getVaultPath(this.state.file) + ); + const header = `--- /dev/null ++++ ${this.state.file} +@@ -0,0 +1,${content.split("\n").length} @@`; + diff2 = [ + ...header.split("\n"), + ...content.split("\n").map((line) => `+${line}`) + ].join("\n"); + } + } + const diffEl = this.parser.parseFromString(html(diff2), "text/html").querySelector(".d2h-file-diff"); + this.contentEl.append(diffEl); + } finally { + this.gettingDiff = false; + } + } + } +}; + +// src/ui/history/historyView.ts +init_polyfill_buffer(); +var import_obsidian20 = require("obsidian"); + +// src/ui/history/historyView.svelte +init_polyfill_buffer(); + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/index.js +init_polyfill_buffer(); + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/animations.js +init_polyfill_buffer(); + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/utils.js +init_polyfill_buffer(); +function noop() { +} +var identity = (x) => x; +function run(fn) { + return fn(); +} +function blank_object() { + return /* @__PURE__ */ Object.create(null); +} +function run_all(fns) { + fns.forEach(run); +} +function is_function(thing) { + return typeof thing === "function"; +} +function safe_not_equal(a, b) { + return a != a ? b == b : a !== b || a && typeof a === "object" || typeof a === "function"; +} +function is_empty(obj) { + return Object.keys(obj).length === 0; +} + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/environment.js +init_polyfill_buffer(); +var is_client = typeof window !== "undefined"; +var now = is_client ? () => window.performance.now() : () => Date.now(); +var raf = is_client ? (cb) => requestAnimationFrame(cb) : noop; + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/loop.js +init_polyfill_buffer(); +var tasks = /* @__PURE__ */ new Set(); +function run_tasks(now2) { + tasks.forEach((task) => { + if (!task.c(now2)) { + tasks.delete(task); + task.f(); + } + }); + if (tasks.size !== 0) + raf(run_tasks); +} +function loop(callback) { + let task; + if (tasks.size === 0) + raf(run_tasks); + return { + promise: new Promise((fulfill) => { + tasks.add(task = { c: callback, f: fulfill }); + }), + abort() { + tasks.delete(task); + } + }; +} + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/style_manager.js +init_polyfill_buffer(); + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/dom.js +init_polyfill_buffer(); + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/ResizeObserverSingleton.js +init_polyfill_buffer(); + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/globals.js +init_polyfill_buffer(); +var globals = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : ( + // @ts-ignore Node typings have this + global +); + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/ResizeObserverSingleton.js +var ResizeObserverSingleton = class _ResizeObserverSingleton { + /** @param {ResizeObserverOptions} options */ + constructor(options) { + /** + * @private + * @readonly + * @type {WeakMap} + */ + __publicField(this, "_listeners", "WeakMap" in globals ? /* @__PURE__ */ new WeakMap() : void 0); + /** + * @private + * @type {ResizeObserver} + */ + __publicField(this, "_observer"); + /** @type {ResizeObserverOptions} */ + __publicField(this, "options"); + this.options = options; + } + /** + * @param {Element} element + * @param {import('./private.js').Listener} listener + * @returns {() => void} + */ + observe(element2, listener) { + this._listeners.set(element2, listener); + this._getObserver().observe(element2, this.options); + return () => { + this._listeners.delete(element2); + this._observer.unobserve(element2); + }; + } + /** + * @private + */ + _getObserver() { + var _a2; + return (_a2 = this._observer) != null ? _a2 : this._observer = new ResizeObserver((entries) => { + var _a3; + for (const entry of entries) { + _ResizeObserverSingleton.entries.set(entry.target, entry); + (_a3 = this._listeners.get(entry.target)) == null ? void 0 : _a3(entry); + } + }); + } +}; +ResizeObserverSingleton.entries = "WeakMap" in globals ? /* @__PURE__ */ new WeakMap() : void 0; + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/dom.js +var is_hydrating = false; +function start_hydrating() { + is_hydrating = true; +} +function end_hydrating() { + is_hydrating = false; +} +function append2(target, node) { + target.appendChild(node); +} +function append_styles(target, style_sheet_id, styles) { + const append_styles_to = get_root_for_style(target); + if (!append_styles_to.getElementById(style_sheet_id)) { + const style = element("style"); + style.id = style_sheet_id; + style.textContent = styles; + append_stylesheet(append_styles_to, style); + } +} +function get_root_for_style(node) { + if (!node) + return document; + const root2 = node.getRootNode ? node.getRootNode() : node.ownerDocument; + if (root2 && /** @type {ShadowRoot} */ + root2.host) { + return ( + /** @type {ShadowRoot} */ + root2 + ); + } + return node.ownerDocument; +} +function append_empty_stylesheet(node) { + const style_element = element("style"); + style_element.textContent = "/* empty */"; + append_stylesheet(get_root_for_style(node), style_element); + return style_element.sheet; +} +function append_stylesheet(node, style) { + append2( + /** @type {Document} */ + node.head || node, + style + ); + return style.sheet; +} +function insert(target, node, anchor) { + target.insertBefore(node, anchor || null); +} +function detach(node) { + if (node.parentNode) { + node.parentNode.removeChild(node); + } +} +function destroy_each(iterations, detaching) { + for (let i = 0; i < iterations.length; i += 1) { + if (iterations[i]) + iterations[i].d(detaching); + } +} +function element(name) { + return document.createElement(name); +} +function text(data) { + return document.createTextNode(data); +} +function space() { + return text(" "); +} +function empty() { + return text(""); +} +function listen(node, event, handler, options) { + node.addEventListener(event, handler, options); + return () => node.removeEventListener(event, handler, options); +} +function stop_propagation(fn) { + return function(event) { + event.stopPropagation(); + return fn.call(this, event); + }; +} +function attr(node, attribute, value) { + if (value == null) + node.removeAttribute(attribute); + else if (node.getAttribute(attribute) !== value) + node.setAttribute(attribute, value); +} +function children(element2) { + return Array.from(element2.childNodes); +} +function set_data(text2, data) { + data = "" + data; + if (text2.data === data) + return; + text2.data = /** @type {string} */ + data; +} +function set_input_value(input, value) { + input.value = value == null ? "" : value; +} +function set_style(node, key2, value, important) { + if (value == null) { + node.style.removeProperty(key2); + } else { + node.style.setProperty(key2, value, important ? "important" : ""); + } +} +function toggle_class(element2, name, toggle) { + element2.classList.toggle(name, !!toggle); +} +function custom_event(type, detail, { bubbles = false, cancelable = false } = {}) { + return new CustomEvent(type, { detail, bubbles, cancelable }); +} +function get_custom_elements_slots(element2) { + const result = {}; + element2.childNodes.forEach( + /** @param {Element} node */ + (node) => { + result[node.slot || "default"] = true; + } + ); + return result; +} + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/style_manager.js +var managed_styles = /* @__PURE__ */ new Map(); +var active = 0; +function hash(str) { + let hash2 = 5381; + let i = str.length; + while (i--) + hash2 = (hash2 << 5) - hash2 ^ str.charCodeAt(i); + return hash2 >>> 0; +} +function create_style_information(doc, node) { + const info = { stylesheet: append_empty_stylesheet(node), rules: {} }; + managed_styles.set(doc, info); + return info; +} +function create_rule(node, a, b, duration, delay2, ease, fn, uid = 0) { + const step = 16.666 / duration; + let keyframes = "{\n"; + for (let p = 0; p <= 1; p += step) { + const t = a + (b - a) * ease(p); + keyframes += p * 100 + `%{${fn(t, 1 - t)}} +`; + } + const rule = keyframes + `100% {${fn(b, 1 - b)}} +}`; + const name = `__svelte_${hash(rule)}_${uid}`; + const doc = get_root_for_style(node); + const { stylesheet, rules } = managed_styles.get(doc) || create_style_information(doc, node); + if (!rules[name]) { + rules[name] = true; + stylesheet.insertRule(`@keyframes ${name} ${rule}`, stylesheet.cssRules.length); + } + const animation = node.style.animation || ""; + node.style.animation = `${animation ? `${animation}, ` : ""}${name} ${duration}ms linear ${delay2}ms 1 both`; + active += 1; + return name; +} +function delete_rule(node, name) { + const previous = (node.style.animation || "").split(", "); + const next = previous.filter( + name ? (anim) => anim.indexOf(name) < 0 : (anim) => anim.indexOf("__svelte") === -1 + // remove all Svelte animations + ); + const deleted = previous.length - next.length; + if (deleted) { + node.style.animation = next.join(", "); + active -= deleted; + if (!active) + clear_rules(); + } +} +function clear_rules() { + raf(() => { + if (active) + return; + managed_styles.forEach((info) => { + const { ownerNode } = info.stylesheet; + if (ownerNode) + detach(ownerNode); + }); + managed_styles.clear(); + }); +} + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/await_block.js +init_polyfill_buffer(); + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/transitions.js +init_polyfill_buffer(); + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/scheduler.js +init_polyfill_buffer(); + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/lifecycle.js +init_polyfill_buffer(); +var current_component; +function set_current_component(component) { + current_component = component; +} +function get_current_component() { + if (!current_component) + throw new Error("Function called outside component initialization"); + return current_component; +} +function onDestroy(fn) { + get_current_component().$$.on_destroy.push(fn); +} +function bubble(component, event) { + const callbacks = component.$$.callbacks[event.type]; + if (callbacks) { + callbacks.slice().forEach((fn) => fn.call(this, event)); + } +} + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/scheduler.js +var dirty_components = []; +var binding_callbacks = []; +var render_callbacks = []; +var flush_callbacks = []; +var resolved_promise = /* @__PURE__ */ Promise.resolve(); +var update_scheduled = false; +function schedule_update() { + if (!update_scheduled) { + update_scheduled = true; + resolved_promise.then(flush); + } +} +function add_render_callback(fn) { + render_callbacks.push(fn); +} +var seen_callbacks = /* @__PURE__ */ new Set(); +var flushidx = 0; +function flush() { + if (flushidx !== 0) { + return; + } + const saved_component = current_component; + do { + try { + while (flushidx < dirty_components.length) { + const component = dirty_components[flushidx]; + flushidx++; + set_current_component(component); + update(component.$$); + } + } catch (e) { + dirty_components.length = 0; + flushidx = 0; + throw e; + } + set_current_component(null); + dirty_components.length = 0; + flushidx = 0; + while (binding_callbacks.length) + binding_callbacks.pop()(); + for (let i = 0; i < render_callbacks.length; i += 1) { + const callback = render_callbacks[i]; + if (!seen_callbacks.has(callback)) { + seen_callbacks.add(callback); + callback(); + } + } + render_callbacks.length = 0; + } while (dirty_components.length); + while (flush_callbacks.length) { + flush_callbacks.pop()(); + } + update_scheduled = false; + seen_callbacks.clear(); + set_current_component(saved_component); +} +function update($$) { + if ($$.fragment !== null) { + $$.update(); + run_all($$.before_update); + const dirty = $$.dirty; + $$.dirty = [-1]; + $$.fragment && $$.fragment.p($$.ctx, dirty); + $$.after_update.forEach(add_render_callback); + } +} +function flush_render_callbacks(fns) { + const filtered = []; + const targets = []; + render_callbacks.forEach((c) => fns.indexOf(c) === -1 ? filtered.push(c) : targets.push(c)); + targets.forEach((c) => c()); + render_callbacks = filtered; +} + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/transitions.js +var promise; +function wait() { + if (!promise) { + promise = Promise.resolve(); + promise.then(() => { + promise = null; + }); + } + return promise; +} +function dispatch(node, direction, kind) { + node.dispatchEvent(custom_event(`${direction ? "intro" : "outro"}${kind}`)); +} +var outroing = /* @__PURE__ */ new Set(); +var outros; +function group_outros() { + outros = { + r: 0, + c: [], + p: outros + // parent group + }; +} +function check_outros() { + if (!outros.r) { + run_all(outros.c); + } + outros = outros.p; +} +function transition_in(block, local) { + if (block && block.i) { + outroing.delete(block); + block.i(local); + } +} +function transition_out(block, local, detach2, callback) { + if (block && block.o) { + if (outroing.has(block)) + return; + outroing.add(block); + outros.c.push(() => { + outroing.delete(block); + if (callback) { + if (detach2) + block.d(1); + callback(); + } + }); + block.o(local); + } else if (callback) { + callback(); + } +} +var null_transition = { duration: 0 }; +function create_bidirectional_transition(node, fn, params, intro) { + const options = { direction: "both" }; + let config = fn(node, params, options); + let t = intro ? 0 : 1; + let running_program = null; + let pending_program = null; + let animation_name = null; + let original_inert_value; + function clear_animation() { + if (animation_name) + delete_rule(node, animation_name); + } + function init3(program, duration) { + const d = ( + /** @type {Program['d']} */ + program.b - t + ); + duration *= Math.abs(d); + return { + a: t, + b: program.b, + d, + duration, + start: program.start, + end: program.start + duration, + group: program.group + }; + } + function go(b) { + const { + delay: delay2 = 0, + duration = 300, + easing = identity, + tick: tick2 = noop, + css + } = config || null_transition; + const program = { + start: now() + delay2, + b + }; + if (!b) { + program.group = outros; + outros.r += 1; + } + if ("inert" in node) { + if (b) { + if (original_inert_value !== void 0) { + node.inert = original_inert_value; + } + } else { + original_inert_value = /** @type {HTMLElement} */ + node.inert; + node.inert = true; + } + } + if (running_program || pending_program) { + pending_program = program; + } else { + if (css) { + clear_animation(); + animation_name = create_rule(node, t, b, duration, delay2, easing, css); + } + if (b) + tick2(0, 1); + running_program = init3(program, duration); + add_render_callback(() => dispatch(node, b, "start")); + loop((now2) => { + if (pending_program && now2 > pending_program.start) { + running_program = init3(pending_program, duration); + pending_program = null; + dispatch(node, running_program.b, "start"); + if (css) { + clear_animation(); + animation_name = create_rule( + node, + t, + running_program.b, + running_program.duration, + 0, + easing, + config.css + ); + } + } + if (running_program) { + if (now2 >= running_program.end) { + tick2(t = running_program.b, 1 - t); + dispatch(node, running_program.b, "end"); + if (!pending_program) { + if (running_program.b) { + clear_animation(); + } else { + if (!--running_program.group.r) + run_all(running_program.group.c); + } + } + running_program = null; + } else if (now2 >= running_program.start) { + const p = now2 - running_program.start; + t = running_program.a + running_program.d * easing(p / running_program.duration); + tick2(t, 1 - t); + } + } + return !!(running_program || pending_program); + }); + } + } + return { + run(b) { + if (is_function(config)) { + wait().then(() => { + const opts = { direction: b ? "in" : "out" }; + config = config(opts); + go(b); + }); + } else { + go(b); + } + }, + end() { + clear_animation(); + running_program = pending_program = null; + } + }; +} + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/each.js +init_polyfill_buffer(); +function ensure_array_like(array_like_or_iterator) { + return (array_like_or_iterator == null ? void 0 : array_like_or_iterator.length) !== void 0 ? array_like_or_iterator : Array.from(array_like_or_iterator); +} + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/spread.js +init_polyfill_buffer(); + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/ssr.js +init_polyfill_buffer(); + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/shared/boolean_attributes.js +init_polyfill_buffer(); +var _boolean_attributes = ( + /** @type {const} */ + [ + "allowfullscreen", + "allowpaymentrequest", + "async", + "autofocus", + "autoplay", + "checked", + "controls", + "default", + "defer", + "disabled", + "formnovalidate", + "hidden", + "inert", + "ismap", + "loop", + "multiple", + "muted", + "nomodule", + "novalidate", + "open", + "playsinline", + "readonly", + "required", + "reversed", + "selected" + ] +); +var boolean_attributes = /* @__PURE__ */ new Set([..._boolean_attributes]); + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/shared/utils/names.js +init_polyfill_buffer(); + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/Component.js +init_polyfill_buffer(); +function create_component(block) { + block && block.c(); +} +function mount_component(component, target, anchor) { + const { fragment, after_update } = component.$$; + fragment && fragment.m(target, anchor); + add_render_callback(() => { + const new_on_destroy = component.$$.on_mount.map(run).filter(is_function); + if (component.$$.on_destroy) { + component.$$.on_destroy.push(...new_on_destroy); + } else { + run_all(new_on_destroy); + } + component.$$.on_mount = []; + }); + after_update.forEach(add_render_callback); +} +function destroy_component(component, detaching) { + const $$ = component.$$; + if ($$.fragment !== null) { + flush_render_callbacks($$.after_update); + run_all($$.on_destroy); + $$.fragment && $$.fragment.d(detaching); + $$.on_destroy = $$.fragment = null; + $$.ctx = []; + } +} +function make_dirty(component, i) { + if (component.$$.dirty[0] === -1) { + dirty_components.push(component); + schedule_update(); + component.$$.dirty.fill(0); + } + component.$$.dirty[i / 31 | 0] |= 1 << i % 31; +} +function init2(component, options, instance10, create_fragment10, not_equal, props, append_styles2, dirty = [-1]) { + const parent_component = current_component; + set_current_component(component); + const $$ = component.$$ = { + fragment: null, + ctx: [], + // state + props, + update: noop, + not_equal, + bound: blank_object(), + // lifecycle + on_mount: [], + on_destroy: [], + on_disconnect: [], + before_update: [], + after_update: [], + context: new Map(options.context || (parent_component ? parent_component.$$.context : [])), + // everything else + callbacks: blank_object(), + dirty, + skip_bound: false, + root: options.target || parent_component.$$.root + }; + append_styles2 && append_styles2($$.root); + let ready = false; + $$.ctx = instance10 ? instance10(component, options.props || {}, (i, ret, ...rest) => { + const value = rest.length ? rest[0] : ret; + if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) { + if (!$$.skip_bound && $$.bound[i]) + $$.bound[i](value); + if (ready) + make_dirty(component, i); + } + return ret; + }) : []; + $$.update(); + ready = true; + run_all($$.before_update); + $$.fragment = create_fragment10 ? create_fragment10($$.ctx) : false; + if (options.target) { + if (options.hydrate) { + start_hydrating(); + const nodes = children(options.target); + $$.fragment && $$.fragment.l(nodes); + nodes.forEach(detach); + } else { + $$.fragment && $$.fragment.c(); + } + if (options.intro) + transition_in(component.$$.fragment); + mount_component(component, options.target, options.anchor); + end_hydrating(); + flush(); + } + set_current_component(parent_component); +} +var SvelteElement; +if (typeof HTMLElement === "function") { + SvelteElement = class extends HTMLElement { + constructor($$componentCtor, $$slots, use_shadow_dom) { + super(); + __publicField(this, "$$componentCtor"); + __publicField(this, "$$slots"); + __publicField(this, "$$component"); + __publicField(this, "$$connected", false); + __publicField(this, "$$data", {}); + __publicField(this, "$$reflecting", false); + /** @type {Record} */ + __publicField(this, "$$props_definition", {}); + /** @type {Record} */ + __publicField(this, "$$listeners", {}); + /** @type {Map} */ + __publicField(this, "$$listener_unsubscribe_fns", /* @__PURE__ */ new Map()); + this.$$componentCtor = $$componentCtor; + this.$$slots = $$slots; + if (use_shadow_dom) { + this.attachShadow({ mode: "open" }); + } + } + addEventListener(type, listener, options) { + this.$$listeners[type] = this.$$listeners[type] || []; + this.$$listeners[type].push(listener); + if (this.$$component) { + const unsub = this.$$component.$on(type, listener); + this.$$listener_unsubscribe_fns.set(listener, unsub); + } + super.addEventListener(type, listener, options); + } + removeEventListener(type, listener, options) { + super.removeEventListener(type, listener, options); + if (this.$$component) { + const unsub = this.$$listener_unsubscribe_fns.get(listener); + if (unsub) { + unsub(); + this.$$listener_unsubscribe_fns.delete(listener); + } + } + } + async connectedCallback() { + this.$$connected = true; + if (!this.$$component) { + let create_slot = function(name) { + return () => { + let node; + const obj = { + c: function create() { + node = document.createElement("slot"); + if (name !== "default") { + node.setAttribute("name", name); + } + }, + /** + * @param {HTMLElement} target + * @param {HTMLElement} [anchor] + */ + m: function mount(target, anchor) { + insert(target, node, anchor); + }, + d: function destroy(detaching) { + if (detaching) { + detach(node); + } + } + }; + return obj; + }; + }; + await Promise.resolve(); + if (!this.$$connected) { + return; + } + const $$slots = {}; + const existing_slots = get_custom_elements_slots(this); + for (const name of this.$$slots) { + if (name in existing_slots) { + $$slots[name] = [create_slot(name)]; + } + } + for (const attribute of this.attributes) { + const name = this.$$get_prop_name(attribute.name); + if (!(name in this.$$data)) { + this.$$data[name] = get_custom_element_value( + name, + attribute.value, + this.$$props_definition, + "toProp" + ); + } + } + this.$$component = new this.$$componentCtor({ + target: this.shadowRoot || this, + props: { + ...this.$$data, + $$slots, + $$scope: { + ctx: [] + } + } + }); + for (const type in this.$$listeners) { + for (const listener of this.$$listeners[type]) { + const unsub = this.$$component.$on(type, listener); + this.$$listener_unsubscribe_fns.set(listener, unsub); + } + } + this.$$listeners = {}; + } + } + // We don't need this when working within Svelte code, but for compatibility of people using this outside of Svelte + // and setting attributes through setAttribute etc, this is helpful + attributeChangedCallback(attr2, _oldValue, newValue) { + var _a2; + if (this.$$reflecting) + return; + attr2 = this.$$get_prop_name(attr2); + this.$$data[attr2] = get_custom_element_value( + attr2, + newValue, + this.$$props_definition, + "toProp" + ); + (_a2 = this.$$component) == null ? void 0 : _a2.$set({ [attr2]: this.$$data[attr2] }); + } + disconnectedCallback() { + this.$$connected = false; + Promise.resolve().then(() => { + if (!this.$$connected) { + this.$$component.$destroy(); + this.$$component = void 0; + } + }); + } + $$get_prop_name(attribute_name) { + return Object.keys(this.$$props_definition).find( + (key2) => this.$$props_definition[key2].attribute === attribute_name || !this.$$props_definition[key2].attribute && key2.toLowerCase() === attribute_name + ) || attribute_name; + } + }; +} +function get_custom_element_value(prop, value, props_definition, transform) { + var _a2; + const type = (_a2 = props_definition[prop]) == null ? void 0 : _a2.type; + value = type === "Boolean" && typeof value !== "boolean" ? value != null : value; + if (!transform || !props_definition[prop]) { + return value; + } else if (transform === "toAttribute") { + switch (type) { + case "Object": + case "Array": + return value == null ? null : JSON.stringify(value); + case "Boolean": + return value ? "" : null; + case "Number": + return value == null ? null : value; + default: + return value; + } + } else { + switch (type) { + case "Object": + case "Array": + return value && JSON.parse(value); + case "Boolean": + return value; + case "Number": + return value != null ? +value : value; + default: + return value; + } + } +} +var SvelteComponent = class { + constructor() { + /** + * ### PRIVATE API + * + * Do not use, may change at any time + * + * @type {any} + */ + __publicField(this, "$$"); + /** + * ### PRIVATE API + * + * Do not use, may change at any time + * + * @type {any} + */ + __publicField(this, "$$set"); + } + /** @returns {void} */ + $destroy() { + destroy_component(this, 1); + this.$destroy = noop; + } + /** + * @template {Extract} K + * @param {K} type + * @param {((e: Events[K]) => void) | null | undefined} callback + * @returns {() => void} + */ + $on(type, callback) { + if (!is_function(callback)) { + return noop; + } + const callbacks = this.$$.callbacks[type] || (this.$$.callbacks[type] = []); + callbacks.push(callback); + return () => { + const index2 = callbacks.indexOf(callback); + if (index2 !== -1) + callbacks.splice(index2, 1); + }; + } + /** + * @param {Partial} props + * @returns {void} + */ + $set(props) { + if (this.$$set && !is_empty(props)) { + this.$$.skip_bound = true; + this.$$set(props); + this.$$.skip_bound = false; + } + } +}; + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/dev.js +init_polyfill_buffer(); + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/shared/version.js +init_polyfill_buffer(); +var PUBLIC_VERSION = "4"; + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/disclose-version/index.js +init_polyfill_buffer(); +if (typeof window !== "undefined") + (window.__svelte || (window.__svelte = { v: /* @__PURE__ */ new Set() })).v.add(PUBLIC_VERSION); + +// node_modules/.pnpm/tslib@2.6.0/node_modules/tslib/tslib.es6.mjs +init_polyfill_buffer(); +function __awaiter(thisArg, _arguments, P, generator) { + function adopt(value) { + return value instanceof P ? value : new P(function(resolve) { + resolve(value); + }); + } + return new (P || (P = Promise))(function(resolve, reject) { + function fulfilled(value) { + try { + step(generator.next(value)); + } catch (e) { + reject(e); + } + } + function rejected(value) { + try { + step(generator["throw"](value)); + } catch (e) { + reject(e); + } + } + function step(result) { + result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); + } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +} + +// src/ui/history/historyView.svelte +var import_obsidian19 = require("obsidian"); + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/index.js +init_polyfill_buffer(); + +// src/ui/history/components/logComponent.svelte +init_polyfill_buffer(); + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/transition/index.js +init_polyfill_buffer(); + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/easing/index.js +init_polyfill_buffer(); +function cubicOut(t) { + const f = t - 1; + return f * f * f + 1; +} + +// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/transition/index.js +function slide(node, { delay: delay2 = 0, duration = 400, easing = cubicOut, axis = "y" } = {}) { + const style = getComputedStyle(node); + const opacity = +style.opacity; + const primary_property = axis === "y" ? "height" : "width"; + const primary_property_value = parseFloat(style[primary_property]); + const secondary_properties = axis === "y" ? ["top", "bottom"] : ["left", "right"]; + const capitalized_secondary_properties = secondary_properties.map( + (e) => `${e[0].toUpperCase()}${e.slice(1)}` + ); + const padding_start_value = parseFloat(style[`padding${capitalized_secondary_properties[0]}`]); + const padding_end_value = parseFloat(style[`padding${capitalized_secondary_properties[1]}`]); + const margin_start_value = parseFloat(style[`margin${capitalized_secondary_properties[0]}`]); + const margin_end_value = parseFloat(style[`margin${capitalized_secondary_properties[1]}`]); + const border_width_start_value = parseFloat( + style[`border${capitalized_secondary_properties[0]}Width`] + ); + const border_width_end_value = parseFloat( + style[`border${capitalized_secondary_properties[1]}Width`] + ); + return { + delay: delay2, + duration, + easing, + css: (t) => `overflow: hidden;opacity: ${Math.min(t * 20, 1) * opacity};${primary_property}: ${t * primary_property_value}px;padding-${secondary_properties[0]}: ${t * padding_start_value}px;padding-${secondary_properties[1]}: ${t * padding_end_value}px;margin-${secondary_properties[0]}: ${t * margin_start_value}px;margin-${secondary_properties[1]}: ${t * margin_end_value}px;border-${secondary_properties[0]}-width: ${t * border_width_start_value}px;border-${secondary_properties[1]}-width: ${t * border_width_end_value}px;` + }; +} + +// src/ui/history/components/logFileComponent.svelte +init_polyfill_buffer(); +var import_obsidian18 = require("obsidian"); +function add_css(target) { + append_styles(target, "svelte-pmbo0n", "main.svelte-pmbo0n .nav-file-title-content.svelte-pmbo0n{display:flex;align-items:center}"); +} +function create_if_block(ctx) { + let div; + let mounted; + let dispose; + return { + c() { + div = element("div"); + attr(div, "data-icon", "go-to-file"); + attr(div, "aria-label", "Open File"); + attr(div, "class", "clickable-icon"); + }, + m(target, anchor) { + insert(target, div, anchor); + ctx[7](div); + if (!mounted) { + dispose = [ + listen(div, "auxclick", stop_propagation( + /*open*/ + ctx[4] + )), + listen(div, "click", stop_propagation( + /*open*/ + ctx[4] + )) + ]; + mounted = true; + } + }, + p: noop, + d(detaching) { + if (detaching) { + detach(div); + } + ctx[7](null); + mounted = false; + run_all(dispose); + } + }; +} +function create_fragment(ctx) { + let main; + let div3; + let div0; + let t0_value = getDisplayPath( + /*diff*/ + ctx[0].vault_path + ) + ""; + let t0; + let t1; + let div2; + let div1; + let show_if = ( + /*view*/ + ctx[1].app.vault.getAbstractFileByPath( + /*diff*/ + ctx[0].vault_path + ) + ); + let t2; + let span; + let t3_value = ( + /*diff*/ + ctx[0].status + "" + ); + let t3; + let span_data_type_value; + let div3_aria_label_value; + let mounted; + let dispose; + let if_block = show_if && create_if_block(ctx); + return { + c() { + main = element("main"); + div3 = element("div"); + div0 = element("div"); + t0 = text(t0_value); + t1 = space(); + div2 = element("div"); + div1 = element("div"); + if (if_block) + if_block.c(); + t2 = space(); + span = element("span"); + t3 = text(t3_value); + attr(div0, "class", "tree-item-inner nav-file-title-content svelte-pmbo0n"); + attr(div1, "class", "buttons"); + attr(span, "class", "type"); + attr(span, "data-type", span_data_type_value = /*diff*/ + ctx[0].status); + attr(div2, "class", "git-tools"); + attr(div3, "class", "tree-item-self is-clickable nav-file-title"); + attr( + div3, + "aria-label-position", + /*side*/ + ctx[3] + ); + attr(div3, "aria-label", div3_aria_label_value = /*diff*/ + ctx[0].vault_path); + attr(main, "class", "tree-item nav-file svelte-pmbo0n"); + }, + m(target, anchor) { + insert(target, main, anchor); + append2(main, div3); + append2(div3, div0); + append2(div0, t0); + append2(div3, t1); + append2(div3, div2); + append2(div2, div1); + if (if_block) + if_block.m(div1, null); + append2(div2, t2); + append2(div2, span); + append2(span, t3); + if (!mounted) { + dispose = [ + listen(main, "click", stop_propagation( + /*showDiff*/ + ctx[5] + )), + listen(main, "auxclick", stop_propagation( + /*showDiff*/ + ctx[5] + )), + listen( + main, + "focus", + /*focus_handler*/ + ctx[6] + ) + ]; + mounted = true; + } + }, + p(ctx2, [dirty]) { + if (dirty & /*diff*/ + 1 && t0_value !== (t0_value = getDisplayPath( + /*diff*/ + ctx2[0].vault_path + ) + "")) + set_data(t0, t0_value); + if (dirty & /*view, diff*/ + 3) + show_if = /*view*/ + ctx2[1].app.vault.getAbstractFileByPath( + /*diff*/ + ctx2[0].vault_path + ); + if (show_if) { + if (if_block) { + if_block.p(ctx2, dirty); + } else { + if_block = create_if_block(ctx2); + if_block.c(); + if_block.m(div1, null); + } + } else if (if_block) { + if_block.d(1); + if_block = null; + } + if (dirty & /*diff*/ + 1 && t3_value !== (t3_value = /*diff*/ + ctx2[0].status + "")) + set_data(t3, t3_value); + if (dirty & /*diff*/ + 1 && span_data_type_value !== (span_data_type_value = /*diff*/ + ctx2[0].status)) { + attr(span, "data-type", span_data_type_value); + } + if (dirty & /*side*/ + 8) { + attr( + div3, + "aria-label-position", + /*side*/ + ctx2[3] + ); + } + if (dirty & /*diff*/ + 1 && div3_aria_label_value !== (div3_aria_label_value = /*diff*/ + ctx2[0].vault_path)) { + attr(div3, "aria-label", div3_aria_label_value); + } + }, + i: noop, + o: noop, + d(detaching) { + if (detaching) { + detach(main); + } + if (if_block) + if_block.d(); + mounted = false; + run_all(dispose); + } + }; +} +function instance($$self, $$props, $$invalidate) { + let side; + let { diff: diff2 } = $$props; + let { view } = $$props; + let buttons = []; + window.setTimeout(() => buttons.forEach((b) => (0, import_obsidian18.setIcon)(b, b.getAttr("data-icon"))), 0); + function open(event) { + var _a2; + const file = view.app.vault.getAbstractFileByPath(diff2.vault_path); + if (file instanceof import_obsidian18.TFile) { + (_a2 = getNewLeaf(event)) === null || _a2 === void 0 ? void 0 : _a2.openFile(file); + } + } + function showDiff(event) { + var _a2; + (_a2 = getNewLeaf(event)) === null || _a2 === void 0 ? void 0 : _a2.setViewState({ + type: DIFF_VIEW_CONFIG.type, + active: true, + state: { + file: diff2.path, + staged: false, + hash: diff2.hash + } + }); + } + function focus_handler(event) { + bubble.call(this, $$self, event); + } + function div_binding($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + buttons[0] = $$value; + $$invalidate(2, buttons); + }); + } + $$self.$$set = ($$props2) => { + if ("diff" in $$props2) + $$invalidate(0, diff2 = $$props2.diff); + if ("view" in $$props2) + $$invalidate(1, view = $$props2.view); + }; + $$self.$$.update = () => { + if ($$self.$$.dirty & /*view*/ + 2) { + $: + $$invalidate(3, side = view.leaf.getRoot().side == "left" ? "right" : "left"); + } + }; + return [diff2, view, buttons, side, open, showDiff, focus_handler, div_binding]; +} +var LogFileComponent = class extends SvelteComponent { + constructor(options) { + super(); + init2(this, options, instance, create_fragment, safe_not_equal, { diff: 0, view: 1 }, add_css); + } +}; +var logFileComponent_default = LogFileComponent; + +// src/ui/history/components/logTreeComponent.svelte +init_polyfill_buffer(); +function add_css2(target) { + append_styles(target, "svelte-1lnl15d", "main.svelte-1lnl15d .nav-folder-title-content.svelte-1lnl15d{display:flex;align-items:center}"); +} +function get_each_context(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[8] = list[i]; + return child_ctx; +} +function create_else_block(ctx) { + let div4; + let div3; + let div0; + let t0; + let div1; + let t1; + let div2; + let t2_value = ( + /*entity*/ + ctx[8].title + "" + ); + let t2; + let div3_aria_label_value; + let t3; + let t4; + let current; + let mounted; + let dispose; + function click_handler() { + return ( + /*click_handler*/ + ctx[7]( + /*entity*/ + ctx[8] + ) + ); + } + let if_block = !/*closed*/ + ctx[4][ + /*entity*/ + ctx[8].title + ] && create_if_block_1(ctx); + return { + c() { + div4 = element("div"); + div3 = element("div"); + div0 = element("div"); + t0 = space(); + div1 = element("div"); + div1.innerHTML = ``; + t1 = space(); + div2 = element("div"); + t2 = text(t2_value); + t3 = space(); + if (if_block) + if_block.c(); + t4 = space(); + attr(div0, "data-icon", "folder"); + set_style(div0, "padding-right", "5px"); + set_style(div0, "display", "flex"); + attr(div1, "class", "tree-item-icon nav-folder-collapse-indicator collapse-icon"); + attr(div2, "class", "tree-item-inner nav-folder-title-content svelte-1lnl15d"); + attr(div3, "class", "tree-item-self is-clickable nav-folder-title"); + attr( + div3, + "aria-label-position", + /*side*/ + ctx[5] + ); + attr(div3, "aria-label", div3_aria_label_value = /*entity*/ + ctx[8].vaultPath); + attr(div4, "class", "tree-item nav-folder"); + toggle_class( + div4, + "is-collapsed", + /*closed*/ + ctx[4][ + /*entity*/ + ctx[8].title + ] + ); + }, + m(target, anchor) { + insert(target, div4, anchor); + append2(div4, div3); + append2(div3, div0); + append2(div3, t0); + append2(div3, div1); + append2(div3, t1); + append2(div3, div2); + append2(div2, t2); + append2(div4, t3); + if (if_block) + if_block.m(div4, null); + append2(div4, t4); + current = true; + if (!mounted) { + dispose = listen(div3, "click", click_handler); + mounted = true; + } + }, + p(new_ctx, dirty) { + ctx = new_ctx; + if ((!current || dirty & /*hierarchy*/ + 1) && t2_value !== (t2_value = /*entity*/ + ctx[8].title + "")) + set_data(t2, t2_value); + if (!current || dirty & /*side*/ + 32) { + attr( + div3, + "aria-label-position", + /*side*/ + ctx[5] + ); + } + if (!current || dirty & /*hierarchy*/ + 1 && div3_aria_label_value !== (div3_aria_label_value = /*entity*/ + ctx[8].vaultPath)) { + attr(div3, "aria-label", div3_aria_label_value); + } + if (!/*closed*/ + ctx[4][ + /*entity*/ + ctx[8].title + ]) { + if (if_block) { + if_block.p(ctx, dirty); + if (dirty & /*closed, hierarchy*/ + 17) { + transition_in(if_block, 1); + } + } else { + if_block = create_if_block_1(ctx); + if_block.c(); + transition_in(if_block, 1); + if_block.m(div4, t4); + } + } else if (if_block) { + group_outros(); + transition_out(if_block, 1, 1, () => { + if_block = null; + }); + check_outros(); + } + if (!current || dirty & /*closed, hierarchy*/ + 17) { + toggle_class( + div4, + "is-collapsed", + /*closed*/ + ctx[4][ + /*entity*/ + ctx[8].title + ] + ); + } + }, + i(local) { + if (current) + return; + transition_in(if_block); + current = true; + }, + o(local) { + transition_out(if_block); + current = false; + }, + d(detaching) { + if (detaching) { + detach(div4); + } + if (if_block) + if_block.d(); + mounted = false; + dispose(); + } + }; +} +function create_if_block2(ctx) { + let div; + let logfilecomponent; + let t; + let current; + logfilecomponent = new logFileComponent_default({ + props: { + diff: ( + /*entity*/ + ctx[8].data + ), + view: ( + /*view*/ + ctx[2] + ) + } + }); + return { + c() { + div = element("div"); + create_component(logfilecomponent.$$.fragment); + t = space(); + }, + m(target, anchor) { + insert(target, div, anchor); + mount_component(logfilecomponent, div, null); + append2(div, t); + current = true; + }, + p(ctx2, dirty) { + const logfilecomponent_changes = {}; + if (dirty & /*hierarchy*/ + 1) + logfilecomponent_changes.diff = /*entity*/ + ctx2[8].data; + if (dirty & /*view*/ + 4) + logfilecomponent_changes.view = /*view*/ + ctx2[2]; + logfilecomponent.$set(logfilecomponent_changes); + }, + i(local) { + if (current) + return; + transition_in(logfilecomponent.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(logfilecomponent.$$.fragment, local); + current = false; + }, + d(detaching) { + if (detaching) { + detach(div); + } + destroy_component(logfilecomponent); + } + }; +} +function create_if_block_1(ctx) { + let div; + let logtreecomponent; + let div_transition; + let current; + logtreecomponent = new LogTreeComponent({ + props: { + hierarchy: ( + /*entity*/ + ctx[8] + ), + plugin: ( + /*plugin*/ + ctx[1] + ), + view: ( + /*view*/ + ctx[2] + ) + } + }); + return { + c() { + div = element("div"); + create_component(logtreecomponent.$$.fragment); + attr(div, "class", "tree-item-children nav-folder-children"); + }, + m(target, anchor) { + insert(target, div, anchor); + mount_component(logtreecomponent, div, null); + current = true; + }, + p(ctx2, dirty) { + const logtreecomponent_changes = {}; + if (dirty & /*hierarchy*/ + 1) + logtreecomponent_changes.hierarchy = /*entity*/ + ctx2[8]; + if (dirty & /*plugin*/ + 2) + logtreecomponent_changes.plugin = /*plugin*/ + ctx2[1]; + if (dirty & /*view*/ + 4) + logtreecomponent_changes.view = /*view*/ + ctx2[2]; + logtreecomponent.$set(logtreecomponent_changes); + }, + i(local) { + if (current) + return; + transition_in(logtreecomponent.$$.fragment, local); + if (local) { + add_render_callback(() => { + if (!current) + return; + if (!div_transition) + div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, true); + div_transition.run(1); + }); + } + current = true; + }, + o(local) { + transition_out(logtreecomponent.$$.fragment, local); + if (local) { + if (!div_transition) + div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, false); + div_transition.run(0); + } + current = false; + }, + d(detaching) { + if (detaching) { + detach(div); + } + destroy_component(logtreecomponent); + if (detaching && div_transition) + div_transition.end(); + } + }; +} +function create_each_block(ctx) { + let current_block_type_index; + let if_block; + let if_block_anchor; + let current; + const if_block_creators = [create_if_block2, create_else_block]; + const if_blocks = []; + function select_block_type(ctx2, dirty) { + if ( + /*entity*/ + ctx2[8].data + ) + return 0; + return 1; + } + current_block_type_index = select_block_type(ctx, -1); + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx); + return { + c() { + if_block.c(); + if_block_anchor = empty(); + }, + m(target, anchor) { + if_blocks[current_block_type_index].m(target, anchor); + insert(target, if_block_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + let previous_block_index = current_block_type_index; + current_block_type_index = select_block_type(ctx2, dirty); + if (current_block_type_index === previous_block_index) { + if_blocks[current_block_type_index].p(ctx2, dirty); + } else { + group_outros(); + transition_out(if_blocks[previous_block_index], 1, 1, () => { + if_blocks[previous_block_index] = null; + }); + check_outros(); + if_block = if_blocks[current_block_type_index]; + if (!if_block) { + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2); + if_block.c(); + } else { + if_block.p(ctx2, dirty); + } + transition_in(if_block, 1); + if_block.m(if_block_anchor.parentNode, if_block_anchor); + } + }, + i(local) { + if (current) + return; + transition_in(if_block); + current = true; + }, + o(local) { + transition_out(if_block); + current = false; + }, + d(detaching) { + if (detaching) { + detach(if_block_anchor); + } + if_blocks[current_block_type_index].d(detaching); + } + }; +} +function create_fragment2(ctx) { + let main; + let current; + let each_value = ensure_array_like( + /*hierarchy*/ + ctx[0].children + ); + let each_blocks = []; + for (let i = 0; i < each_value.length; i += 1) { + each_blocks[i] = create_each_block(get_each_context(ctx, each_value, i)); + } + const out = (i) => transition_out(each_blocks[i], 1, 1, () => { + each_blocks[i] = null; + }); + return { + c() { + main = element("main"); + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + attr(main, "class", "svelte-1lnl15d"); + toggle_class( + main, + "topLevel", + /*topLevel*/ + ctx[3] + ); + }, + m(target, anchor) { + insert(target, main, anchor); + for (let i = 0; i < each_blocks.length; i += 1) { + if (each_blocks[i]) { + each_blocks[i].m(main, null); + } + } + current = true; + }, + p(ctx2, [dirty]) { + if (dirty & /*hierarchy, view, closed, plugin, side, fold*/ + 119) { + each_value = ensure_array_like( + /*hierarchy*/ + ctx2[0].children + ); + let i; + for (i = 0; i < each_value.length; i += 1) { + const child_ctx = get_each_context(ctx2, each_value, i); + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + transition_in(each_blocks[i], 1); + } else { + each_blocks[i] = create_each_block(child_ctx); + each_blocks[i].c(); + transition_in(each_blocks[i], 1); + each_blocks[i].m(main, null); + } + } + group_outros(); + for (i = each_value.length; i < each_blocks.length; i += 1) { + out(i); + } + check_outros(); + } + if (!current || dirty & /*topLevel*/ + 8) { + toggle_class( + main, + "topLevel", + /*topLevel*/ + ctx2[3] + ); + } + }, + i(local) { + if (current) + return; + for (let i = 0; i < each_value.length; i += 1) { + transition_in(each_blocks[i]); + } + current = true; + }, + o(local) { + each_blocks = each_blocks.filter(Boolean); + for (let i = 0; i < each_blocks.length; i += 1) { + transition_out(each_blocks[i]); + } + current = false; + }, + d(detaching) { + if (detaching) { + detach(main); + } + destroy_each(each_blocks, detaching); + } + }; +} +function instance2($$self, $$props, $$invalidate) { + let side; + let { hierarchy } = $$props; + let { plugin } = $$props; + let { view } = $$props; + let { topLevel = false } = $$props; + const closed = {}; + function fold(item) { + $$invalidate(4, closed[item.title] = !closed[item.title], closed); + } + const click_handler = (entity) => fold(entity); + $$self.$$set = ($$props2) => { + if ("hierarchy" in $$props2) + $$invalidate(0, hierarchy = $$props2.hierarchy); + if ("plugin" in $$props2) + $$invalidate(1, plugin = $$props2.plugin); + if ("view" in $$props2) + $$invalidate(2, view = $$props2.view); + if ("topLevel" in $$props2) + $$invalidate(3, topLevel = $$props2.topLevel); + }; + $$self.$$.update = () => { + if ($$self.$$.dirty & /*view*/ + 4) { + $: + $$invalidate(5, side = view.leaf.getRoot().side == "left" ? "right" : "left"); + } + }; + return [hierarchy, plugin, view, topLevel, closed, side, fold, click_handler]; +} +var LogTreeComponent = class extends SvelteComponent { + constructor(options) { + super(); + init2( + this, + options, + instance2, + create_fragment2, + safe_not_equal, + { + hierarchy: 0, + plugin: 1, + view: 2, + topLevel: 3 + }, + add_css2 + ); + } +}; +var logTreeComponent_default = LogTreeComponent; + +// src/ui/history/components/logComponent.svelte +function add_css3(target) { + append_styles(target, "svelte-1t6egnt", ".git-ref.svelte-1t6egnt{color:var(--text-accent)}"); +} +function get_each_context2(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[8] = list[i]; + return child_ctx; +} +function create_if_block_2(ctx) { + let div; + let t_value = ( + /*log*/ + ctx[0].refs.join(", ") + "" + ); + let t; + return { + c() { + div = element("div"); + t = text(t_value); + attr(div, "class", "git-ref svelte-1t6egnt"); + }, + m(target, anchor) { + insert(target, div, anchor); + append2(div, t); + }, + p(ctx2, dirty) { + if (dirty & /*log*/ + 1 && t_value !== (t_value = /*log*/ + ctx2[0].refs.join(", ") + "")) + set_data(t, t_value); + }, + d(detaching) { + if (detaching) { + detach(div); + } + } + }; +} +function create_if_block3(ctx) { + let div; + let current_block_type_index; + let if_block; + let div_transition; + let current; + const if_block_creators = [create_if_block_12, create_else_block2]; + const if_blocks = []; + function select_block_type(ctx2, dirty) { + if ( + /*showTree*/ + ctx2[2] + ) + return 0; + return 1; + } + current_block_type_index = select_block_type(ctx, -1); + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx); + return { + c() { + div = element("div"); + if_block.c(); + attr(div, "class", "tree-item-children nav-folder-children"); + }, + m(target, anchor) { + insert(target, div, anchor); + if_blocks[current_block_type_index].m(div, null); + current = true; + }, + p(ctx2, dirty) { + let previous_block_index = current_block_type_index; + current_block_type_index = select_block_type(ctx2, dirty); + if (current_block_type_index === previous_block_index) { + if_blocks[current_block_type_index].p(ctx2, dirty); + } else { + group_outros(); + transition_out(if_blocks[previous_block_index], 1, 1, () => { + if_blocks[previous_block_index] = null; + }); + check_outros(); + if_block = if_blocks[current_block_type_index]; + if (!if_block) { + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2); + if_block.c(); + } else { + if_block.p(ctx2, dirty); + } + transition_in(if_block, 1); + if_block.m(div, null); + } + }, + i(local) { + if (current) + return; + transition_in(if_block); + if (local) { + add_render_callback(() => { + if (!current) + return; + if (!div_transition) + div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, true); + div_transition.run(1); + }); + } + current = true; + }, + o(local) { + transition_out(if_block); + if (local) { + if (!div_transition) + div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, false); + div_transition.run(0); + } + current = false; + }, + d(detaching) { + if (detaching) { + detach(div); + } + if_blocks[current_block_type_index].d(); + if (detaching && div_transition) + div_transition.end(); + } + }; +} +function create_else_block2(ctx) { + let each_1_anchor; + let current; + let each_value = ensure_array_like( + /*log*/ + ctx[0].diff.files + ); + let each_blocks = []; + for (let i = 0; i < each_value.length; i += 1) { + each_blocks[i] = create_each_block2(get_each_context2(ctx, each_value, i)); + } + const out = (i) => transition_out(each_blocks[i], 1, 1, () => { + each_blocks[i] = null; + }); + return { + c() { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + each_1_anchor = empty(); + }, + m(target, anchor) { + for (let i = 0; i < each_blocks.length; i += 1) { + if (each_blocks[i]) { + each_blocks[i].m(target, anchor); + } + } + insert(target, each_1_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + if (dirty & /*view, log*/ + 3) { + each_value = ensure_array_like( + /*log*/ + ctx2[0].diff.files + ); + let i; + for (i = 0; i < each_value.length; i += 1) { + const child_ctx = get_each_context2(ctx2, each_value, i); + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + transition_in(each_blocks[i], 1); + } else { + each_blocks[i] = create_each_block2(child_ctx); + each_blocks[i].c(); + transition_in(each_blocks[i], 1); + each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor); + } + } + group_outros(); + for (i = each_value.length; i < each_blocks.length; i += 1) { + out(i); + } + check_outros(); + } + }, + i(local) { + if (current) + return; + for (let i = 0; i < each_value.length; i += 1) { + transition_in(each_blocks[i]); + } + current = true; + }, + o(local) { + each_blocks = each_blocks.filter(Boolean); + for (let i = 0; i < each_blocks.length; i += 1) { + transition_out(each_blocks[i]); + } + current = false; + }, + d(detaching) { + if (detaching) { + detach(each_1_anchor); + } + destroy_each(each_blocks, detaching); + } + }; +} +function create_if_block_12(ctx) { + let logtreecomponent; + let current; + logtreecomponent = new logTreeComponent_default({ + props: { + hierarchy: ( + /*logsHierarchy*/ + ctx[6] + ), + plugin: ( + /*plugin*/ + ctx[3] + ), + view: ( + /*view*/ + ctx[1] + ), + topLevel: true + } + }); + return { + c() { + create_component(logtreecomponent.$$.fragment); + }, + m(target, anchor) { + mount_component(logtreecomponent, target, anchor); + current = true; + }, + p(ctx2, dirty) { + const logtreecomponent_changes = {}; + if (dirty & /*logsHierarchy*/ + 64) + logtreecomponent_changes.hierarchy = /*logsHierarchy*/ + ctx2[6]; + if (dirty & /*plugin*/ + 8) + logtreecomponent_changes.plugin = /*plugin*/ + ctx2[3]; + if (dirty & /*view*/ + 2) + logtreecomponent_changes.view = /*view*/ + ctx2[1]; + logtreecomponent.$set(logtreecomponent_changes); + }, + i(local) { + if (current) + return; + transition_in(logtreecomponent.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(logtreecomponent.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(logtreecomponent, detaching); + } + }; +} +function create_each_block2(ctx) { + let logfilecomponent; + let current; + logfilecomponent = new logFileComponent_default({ + props: { + view: ( + /*view*/ + ctx[1] + ), + diff: ( + /*file*/ + ctx[8] + ) + } + }); + return { + c() { + create_component(logfilecomponent.$$.fragment); + }, + m(target, anchor) { + mount_component(logfilecomponent, target, anchor); + current = true; + }, + p(ctx2, dirty) { + const logfilecomponent_changes = {}; + if (dirty & /*view*/ + 2) + logfilecomponent_changes.view = /*view*/ + ctx2[1]; + if (dirty & /*log*/ + 1) + logfilecomponent_changes.diff = /*file*/ + ctx2[8]; + logfilecomponent.$set(logfilecomponent_changes); + }, + i(local) { + if (current) + return; + transition_in(logfilecomponent.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(logfilecomponent.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(logfilecomponent, detaching); + } + }; +} +function create_fragment3(ctx) { + let main; + let div4; + let div3; + let div0; + let t0; + let div2; + let t1; + let div1; + let t2_value = ( + /*log*/ + ctx[0].message + "" + ); + let t2; + let div1_aria_label_value; + let t3; + let current; + let mounted; + let dispose; + let if_block0 = ( + /*log*/ + ctx[0].refs.length > 0 && create_if_block_2(ctx) + ); + let if_block1 = !/*isCollapsed*/ + ctx[4] && create_if_block3(ctx); + return { + c() { + main = element("main"); + div4 = element("div"); + div3 = element("div"); + div0 = element("div"); + div0.innerHTML = ``; + t0 = space(); + div2 = element("div"); + if (if_block0) + if_block0.c(); + t1 = space(); + div1 = element("div"); + t2 = text(t2_value); + t3 = space(); + if (if_block1) + if_block1.c(); + attr(div0, "class", "tree-item-icon nav-folder-collapse-indicator collapse-icon"); + attr(div1, "class", "tree-item-inner nav-folder-title-content"); + attr(div1, "aria-label", div1_aria_label_value = /*log*/ + ctx[0].message); + attr( + div1, + "aria-label-position", + /*side*/ + ctx[5] + ); + attr(div3, "class", "tree-item-self is-clickable nav-folder-title"); + attr(div4, "class", "tree-item nav-folder"); + toggle_class( + div4, + "is-collapsed", + /*isCollapsed*/ + ctx[4] + ); + }, + m(target, anchor) { + insert(target, main, anchor); + append2(main, div4); + append2(div4, div3); + append2(div3, div0); + append2(div3, t0); + append2(div3, div2); + if (if_block0) + if_block0.m(div2, null); + append2(div2, t1); + append2(div2, div1); + append2(div1, t2); + append2(div4, t3); + if (if_block1) + if_block1.m(div4, null); + current = true; + if (!mounted) { + dispose = listen( + div3, + "click", + /*click_handler*/ + ctx[7] + ); + mounted = true; + } + }, + p(ctx2, [dirty]) { + if ( + /*log*/ + ctx2[0].refs.length > 0 + ) { + if (if_block0) { + if_block0.p(ctx2, dirty); + } else { + if_block0 = create_if_block_2(ctx2); + if_block0.c(); + if_block0.m(div2, t1); + } + } else if (if_block0) { + if_block0.d(1); + if_block0 = null; + } + if ((!current || dirty & /*log*/ + 1) && t2_value !== (t2_value = /*log*/ + ctx2[0].message + "")) + set_data(t2, t2_value); + if (!current || dirty & /*log*/ + 1 && div1_aria_label_value !== (div1_aria_label_value = /*log*/ + ctx2[0].message)) { + attr(div1, "aria-label", div1_aria_label_value); + } + if (!current || dirty & /*side*/ + 32) { + attr( + div1, + "aria-label-position", + /*side*/ + ctx2[5] + ); + } + if (!/*isCollapsed*/ + ctx2[4]) { + if (if_block1) { + if_block1.p(ctx2, dirty); + if (dirty & /*isCollapsed*/ + 16) { + transition_in(if_block1, 1); + } + } else { + if_block1 = create_if_block3(ctx2); + if_block1.c(); + transition_in(if_block1, 1); + if_block1.m(div4, null); + } + } else if (if_block1) { + group_outros(); + transition_out(if_block1, 1, 1, () => { + if_block1 = null; + }); + check_outros(); + } + if (!current || dirty & /*isCollapsed*/ + 16) { + toggle_class( + div4, + "is-collapsed", + /*isCollapsed*/ + ctx2[4] + ); + } + }, + i(local) { + if (current) + return; + transition_in(if_block1); + current = true; + }, + o(local) { + transition_out(if_block1); + current = false; + }, + d(detaching) { + if (detaching) { + detach(main); + } + if (if_block0) + if_block0.d(); + if (if_block1) + if_block1.d(); + mounted = false; + dispose(); + } + }; +} +function instance3($$self, $$props, $$invalidate) { + let logsHierarchy; + let side; + let { log: log2 } = $$props; + let { view } = $$props; + let { showTree } = $$props; + let { plugin } = $$props; + let isCollapsed = true; + const click_handler = () => $$invalidate(4, isCollapsed = !isCollapsed); + $$self.$$set = ($$props2) => { + if ("log" in $$props2) + $$invalidate(0, log2 = $$props2.log); + if ("view" in $$props2) + $$invalidate(1, view = $$props2.view); + if ("showTree" in $$props2) + $$invalidate(2, showTree = $$props2.showTree); + if ("plugin" in $$props2) + $$invalidate(3, plugin = $$props2.plugin); + }; + $$self.$$.update = () => { + if ($$self.$$.dirty & /*plugin, log*/ + 9) { + $: + $$invalidate(6, logsHierarchy = { + title: "", + path: "", + vaultPath: "", + children: plugin.gitManager.getTreeStructure(log2.diff.files) + }); + } + if ($$self.$$.dirty & /*view*/ + 2) { + $: + $$invalidate(5, side = view.leaf.getRoot().side == "left" ? "right" : "left"); + } + }; + return [log2, view, showTree, plugin, isCollapsed, side, logsHierarchy, click_handler]; +} +var LogComponent = class extends SvelteComponent { + constructor(options) { + super(); + init2(this, options, instance3, create_fragment3, safe_not_equal, { log: 0, view: 1, showTree: 2, plugin: 3 }, add_css3); + } +}; +var logComponent_default = LogComponent; + +// src/ui/history/historyView.svelte +function get_each_context3(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[11] = list[i]; + return child_ctx; +} +function create_if_block4(ctx) { + let div1; + let div0; + let current; + let each_value = ensure_array_like( + /*logs*/ + ctx[6] + ); + let each_blocks = []; + for (let i = 0; i < each_value.length; i += 1) { + each_blocks[i] = create_each_block3(get_each_context3(ctx, each_value, i)); + } + const out = (i) => transition_out(each_blocks[i], 1, 1, () => { + each_blocks[i] = null; + }); + return { + c() { + div1 = element("div"); + div0 = element("div"); + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + attr(div0, "class", "tree-item-children nav-folder-children"); + attr(div1, "class", "tree-item nav-folder mod-root"); + }, + m(target, anchor) { + insert(target, div1, anchor); + append2(div1, div0); + for (let i = 0; i < each_blocks.length; i += 1) { + if (each_blocks[i]) { + each_blocks[i].m(div0, null); + } + } + current = true; + }, + p(ctx2, dirty) { + if (dirty & /*view, showTree, logs, plugin*/ + 71) { + each_value = ensure_array_like( + /*logs*/ + ctx2[6] + ); + let i; + for (i = 0; i < each_value.length; i += 1) { + const child_ctx = get_each_context3(ctx2, each_value, i); + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + transition_in(each_blocks[i], 1); + } else { + each_blocks[i] = create_each_block3(child_ctx); + each_blocks[i].c(); + transition_in(each_blocks[i], 1); + each_blocks[i].m(div0, null); + } + } + group_outros(); + for (i = each_value.length; i < each_blocks.length; i += 1) { + out(i); + } + check_outros(); + } + }, + i(local) { + if (current) + return; + for (let i = 0; i < each_value.length; i += 1) { + transition_in(each_blocks[i]); + } + current = true; + }, + o(local) { + each_blocks = each_blocks.filter(Boolean); + for (let i = 0; i < each_blocks.length; i += 1) { + transition_out(each_blocks[i]); + } + current = false; + }, + d(detaching) { + if (detaching) { + detach(div1); + } + destroy_each(each_blocks, detaching); + } + }; +} +function create_each_block3(ctx) { + let logcomponent; + let current; + logcomponent = new logComponent_default({ + props: { + view: ( + /*view*/ + ctx[1] + ), + showTree: ( + /*showTree*/ + ctx[2] + ), + log: ( + /*log*/ + ctx[11] + ), + plugin: ( + /*plugin*/ + ctx[0] + ) + } + }); + return { + c() { + create_component(logcomponent.$$.fragment); + }, + m(target, anchor) { + mount_component(logcomponent, target, anchor); + current = true; + }, + p(ctx2, dirty) { + const logcomponent_changes = {}; + if (dirty & /*view*/ + 2) + logcomponent_changes.view = /*view*/ + ctx2[1]; + if (dirty & /*showTree*/ + 4) + logcomponent_changes.showTree = /*showTree*/ + ctx2[2]; + if (dirty & /*logs*/ + 64) + logcomponent_changes.log = /*log*/ + ctx2[11]; + if (dirty & /*plugin*/ + 1) + logcomponent_changes.plugin = /*plugin*/ + ctx2[0]; + logcomponent.$set(logcomponent_changes); + }, + i(local) { + if (current) + return; + transition_in(logcomponent.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(logcomponent.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(logcomponent, detaching); + } + }; +} +function create_fragment4(ctx) { + let main; + let div3; + let div2; + let div0; + let t0; + let div1; + let t1; + let div4; + let current; + let mounted; + let dispose; + let if_block = ( + /*logs*/ + ctx[6] && create_if_block4(ctx) + ); + return { + c() { + main = element("main"); + div3 = element("div"); + div2 = element("div"); + div0 = element("div"); + t0 = space(); + div1 = element("div"); + t1 = space(); + div4 = element("div"); + if (if_block) + if_block.c(); + attr(div0, "id", "layoutChange"); + attr(div0, "class", "clickable-icon nav-action-button"); + attr(div0, "aria-label", "Change Layout"); + attr(div1, "id", "refresh"); + attr(div1, "class", "clickable-icon nav-action-button"); + attr(div1, "data-icon", "refresh-cw"); + attr(div1, "aria-label", "Refresh"); + set_style(div1, "margin", "1px"); + toggle_class( + div1, + "loading", + /*loading*/ + ctx[4] + ); + attr(div2, "class", "nav-buttons-container"); + attr(div3, "class", "nav-header"); + attr(div4, "class", "nav-files-container"); + set_style(div4, "position", "relative"); + }, + m(target, anchor) { + insert(target, main, anchor); + append2(main, div3); + append2(div3, div2); + append2(div2, div0); + ctx[7](div0); + append2(div2, t0); + append2(div2, div1); + ctx[9](div1); + append2(main, t1); + append2(main, div4); + if (if_block) + if_block.m(div4, null); + current = true; + if (!mounted) { + dispose = [ + listen( + div0, + "click", + /*click_handler*/ + ctx[8] + ), + listen(div1, "click", triggerRefresh) + ]; + mounted = true; + } + }, + p(ctx2, [dirty]) { + if (!current || dirty & /*loading*/ + 16) { + toggle_class( + div1, + "loading", + /*loading*/ + ctx2[4] + ); + } + if ( + /*logs*/ + ctx2[6] + ) { + if (if_block) { + if_block.p(ctx2, dirty); + if (dirty & /*logs*/ + 64) { + transition_in(if_block, 1); + } + } else { + if_block = create_if_block4(ctx2); + if_block.c(); + transition_in(if_block, 1); + if_block.m(div4, null); + } + } else if (if_block) { + group_outros(); + transition_out(if_block, 1, 1, () => { + if_block = null; + }); + check_outros(); + } + }, + i(local) { + if (current) + return; + transition_in(if_block); + current = true; + }, + o(local) { + transition_out(if_block); + current = false; + }, + d(detaching) { + if (detaching) { + detach(main); + } + ctx[7](null); + ctx[9](null); + if (if_block) + if_block.d(); + mounted = false; + run_all(dispose); + } + }; +} +function triggerRefresh() { + dispatchEvent(new CustomEvent("git-refresh")); +} +function instance4($$self, $$props, $$invalidate) { + let { plugin } = $$props; + let { view } = $$props; + let loading; + let buttons = []; + let logs; + let showTree = plugin.settings.treeStructure; + let layoutBtn; + addEventListener("git-view-refresh", refresh); + plugin.app.workspace.onLayoutReady(() => { + window.setTimeout( + () => { + buttons.forEach((btn) => (0, import_obsidian19.setIcon)(btn, btn.getAttr("data-icon"), 16)); + (0, import_obsidian19.setIcon)(layoutBtn, showTree ? "list" : "folder", 16); + }, + 0 + ); + }); + onDestroy(() => { + removeEventListener("git-view-refresh", refresh); + }); + function refresh() { + return __awaiter(this, void 0, void 0, function* () { + $$invalidate(4, loading = true); + const isSimpleGit = plugin.gitManager instanceof SimpleGit; + $$invalidate(6, logs = yield plugin.gitManager.log(void 0, false, isSimpleGit ? 50 : 10)); + $$invalidate(4, loading = false); + }); + } + function div0_binding($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + layoutBtn = $$value; + $$invalidate(3, layoutBtn); + }); + } + const click_handler = () => { + $$invalidate(2, showTree = !showTree); + $$invalidate(0, plugin.settings.treeStructure = showTree, plugin); + plugin.saveSettings(); + }; + function div1_binding($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + buttons[6] = $$value; + $$invalidate(5, buttons); + }); + } + $$self.$$set = ($$props2) => { + if ("plugin" in $$props2) + $$invalidate(0, plugin = $$props2.plugin); + if ("view" in $$props2) + $$invalidate(1, view = $$props2.view); + }; + $$self.$$.update = () => { + if ($$self.$$.dirty & /*layoutBtn, showTree*/ + 12) { + $: { + if (layoutBtn) { + layoutBtn.empty(); + (0, import_obsidian19.setIcon)(layoutBtn, showTree ? "list" : "folder", 16); + } + } + } + }; + return [ + plugin, + view, + showTree, + layoutBtn, + loading, + buttons, + logs, + div0_binding, + click_handler, + div1_binding + ]; +} +var HistoryView = class extends SvelteComponent { + constructor(options) { + super(); + init2(this, options, instance4, create_fragment4, safe_not_equal, { plugin: 0, view: 1 }); + } +}; +var historyView_default = HistoryView; + +// src/ui/history/historyView.ts +var HistoryView2 = class extends import_obsidian20.ItemView { + constructor(leaf, plugin) { + super(leaf); + this.plugin = plugin; + this.hoverPopover = null; + } + getViewType() { + return HISTORY_VIEW_CONFIG.type; + } + getDisplayText() { + return HISTORY_VIEW_CONFIG.name; + } + getIcon() { + return HISTORY_VIEW_CONFIG.icon; + } + onClose() { + return super.onClose(); + } + onOpen() { + this._view = new historyView_default({ + target: this.contentEl, + props: { + plugin: this.plugin, + view: this + } + }); + return super.onOpen(); + } +}; + +// src/ui/modals/branchModal.ts +init_polyfill_buffer(); +var import_obsidian21 = require("obsidian"); +var BranchModal = class extends import_obsidian21.FuzzySuggestModal { + constructor(branches) { + super(app); + this.branches = branches; + this.setPlaceholder("Select branch to checkout"); + } + getItems() { + return this.branches; + } + getItemText(item) { + return item; + } + onChooseItem(item, evt) { + this.resolve(item); + } + open() { + super.open(); + return new Promise((resolve) => { + this.resolve = resolve; + }); + } + async onClose() { + await new Promise((resolve) => setTimeout(resolve, 10)); + if (this.resolve) + this.resolve(void 0); + } +}; + +// src/ui/modals/ignoreModal.ts +init_polyfill_buffer(); +var import_obsidian22 = require("obsidian"); +var IgnoreModal = class extends import_obsidian22.Modal { + constructor(app2, content) { + super(app2); + this.content = content; + this.resolve = null; + } + open() { + super.open(); + return new Promise((resolve) => { + this.resolve = resolve; + }); + } + onOpen() { + const { contentEl, titleEl } = this; + titleEl.setText("Edit .gitignore"); + const div = contentEl.createDiv(); + const text2 = div.createEl("textarea", { + text: this.content, + cls: ["obsidian-git-textarea"], + attr: { rows: 10, cols: 30, wrap: "off" } + }); + div.createEl("button", { + cls: ["mod-cta", "obsidian-git-center-button"], + text: "Save" + }).addEventListener("click", async () => { + this.resolve(text2.value); + this.close(); + }); + } + onClose() { + const { contentEl } = this; + this.resolve(void 0); + contentEl.empty(); + } +}; + +// src/ui/sourceControl/sourceControl.ts +init_polyfill_buffer(); +var import_obsidian29 = require("obsidian"); + +// src/ui/sourceControl/sourceControl.svelte +init_polyfill_buffer(); +var import_obsidian28 = require("obsidian"); + +// src/ui/modals/discardModal.ts +init_polyfill_buffer(); +var import_obsidian23 = require("obsidian"); +var DiscardModal = class extends import_obsidian23.Modal { + constructor(app2, deletion, filename) { + super(app2); + this.deletion = deletion; + this.filename = filename; + this.resolve = null; + } + myOpen() { + this.open(); + return new Promise((resolve) => { + this.resolve = resolve; + }); + } + onOpen() { + const { contentEl, titleEl } = this; + titleEl.setText(`${this.deletion ? "Delete" : "Discard"} this file?`); + contentEl.createEl("p").setText( + `Do you really want to ${this.deletion ? "delete" : "discard the changes of"} "${this.filename}"` + ); + const div = contentEl.createDiv({ cls: "modal-button-container" }); + const discard = div.createEl("button", { + cls: "mod-warning", + text: this.deletion ? "Delete" : "Discard" + }); + discard.addEventListener("click", async () => { + if (this.resolve) + this.resolve(true); + this.close(); + }); + discard.addEventListener("keypress", async () => { + if (this.resolve) + this.resolve(true); + this.close(); + }); + const close = div.createEl("button", { + text: "Cancel" + }); + close.addEventListener("click", () => { + if (this.resolve) + this.resolve(false); + return this.close(); + }); + close.addEventListener("keypress", () => { + if (this.resolve) + this.resolve(false); + return this.close(); + }); + } + onClose() { + const { contentEl } = this; + contentEl.empty(); + } +}; + +// src/ui/sourceControl/components/fileComponent.svelte +init_polyfill_buffer(); +var import_obsidian25 = require("obsidian"); + +// node_modules/.pnpm/obsidian-community-lib@2.0.2_@codemirror+state@6.2.1_@codemirror+view@6.14.0/node_modules/obsidian-community-lib/dist/index.js +init_polyfill_buffer(); + +// node_modules/.pnpm/obsidian-community-lib@2.0.2_@codemirror+state@6.2.1_@codemirror+view@6.14.0/node_modules/obsidian-community-lib/dist/utils.js +init_polyfill_buffer(); +var feather = __toESM(require_feather()); +var import_obsidian24 = require("obsidian"); +function hoverPreview(event, view, to) { + const targetEl = event.target; + app.workspace.trigger("hover-link", { + event, + source: view.getViewType(), + hoverParent: view, + targetEl, + linktext: to + }); +} + +// src/ui/sourceControl/components/fileComponent.svelte +function add_css4(target) { + append_styles(target, "svelte-pmbo0n", "main.svelte-pmbo0n .nav-file-title-content.svelte-pmbo0n{display:flex;align-items:center}"); +} +function create_if_block5(ctx) { + let div; + let mounted; + let dispose; + return { + c() { + div = element("div"); + attr(div, "data-icon", "go-to-file"); + attr(div, "aria-label", "Open File"); + attr(div, "class", "clickable-icon"); + }, + m(target, anchor) { + insert(target, div, anchor); + ctx[11](div); + if (!mounted) { + dispose = [ + listen(div, "auxclick", stop_propagation( + /*open*/ + ctx[5] + )), + listen(div, "click", stop_propagation( + /*open*/ + ctx[5] + )) + ]; + mounted = true; + } + }, + p: noop, + d(detaching) { + if (detaching) { + detach(div); + } + ctx[11](null); + mounted = false; + run_all(dispose); + } + }; +} +function create_fragment5(ctx) { + let main; + let div6; + let div0; + let t0_value = getDisplayPath( + /*change*/ + ctx[0].vault_path + ) + ""; + let t0; + let t1; + let div5; + let div3; + let show_if = ( + /*view*/ + ctx[1].app.vault.getAbstractFileByPath( + /*change*/ + ctx[0].vault_path + ) + ); + let t2; + let div1; + let t3; + let div2; + let t4; + let div4; + let t5_value = ( + /*change*/ + ctx[0].working_dir + "" + ); + let t5; + let div4_data_type_value; + let div6_aria_label_value; + let mounted; + let dispose; + let if_block = show_if && create_if_block5(ctx); + return { + c() { + main = element("main"); + div6 = element("div"); + div0 = element("div"); + t0 = text(t0_value); + t1 = space(); + div5 = element("div"); + div3 = element("div"); + if (if_block) + if_block.c(); + t2 = space(); + div1 = element("div"); + t3 = space(); + div2 = element("div"); + t4 = space(); + div4 = element("div"); + t5 = text(t5_value); + attr(div0, "class", "tree-item-inner nav-file-title-content svelte-pmbo0n"); + attr(div1, "data-icon", "undo"); + attr(div1, "aria-label", "Discard"); + attr(div1, "class", "clickable-icon"); + attr(div2, "data-icon", "plus"); + attr(div2, "aria-label", "Stage"); + attr(div2, "class", "clickable-icon"); + attr(div3, "class", "buttons"); + attr(div4, "class", "type"); + attr(div4, "data-type", div4_data_type_value = /*change*/ + ctx[0].working_dir); + attr(div5, "class", "git-tools"); + attr(div6, "class", "tree-item-self is-clickable nav-file-title"); + attr( + div6, + "aria-label-position", + /*side*/ + ctx[3] + ); + attr(div6, "aria-label", div6_aria_label_value = /*change*/ + ctx[0].vault_path); + attr(main, "class", "tree-item nav-file svelte-pmbo0n"); + }, + m(target, anchor) { + insert(target, main, anchor); + append2(main, div6); + append2(div6, div0); + append2(div0, t0); + append2(div6, t1); + append2(div6, div5); + append2(div5, div3); + if (if_block) + if_block.m(div3, null); + append2(div3, t2); + append2(div3, div1); + ctx[12](div1); + append2(div3, t3); + append2(div3, div2); + ctx[13](div2); + append2(div5, t4); + append2(div5, div4); + append2(div4, t5); + if (!mounted) { + dispose = [ + listen(div1, "click", stop_propagation( + /*discard*/ + ctx[8] + )), + listen(div2, "click", stop_propagation( + /*stage*/ + ctx[6] + )), + listen( + main, + "mouseover", + /*hover*/ + ctx[4] + ), + listen(main, "click", stop_propagation( + /*showDiff*/ + ctx[7] + )), + listen(main, "auxclick", stop_propagation( + /*showDiff*/ + ctx[7] + )), + listen( + main, + "focus", + /*focus_handler*/ + ctx[10] + ) + ]; + mounted = true; + } + }, + p(ctx2, [dirty]) { + if (dirty & /*change*/ + 1 && t0_value !== (t0_value = getDisplayPath( + /*change*/ + ctx2[0].vault_path + ) + "")) + set_data(t0, t0_value); + if (dirty & /*view, change*/ + 3) + show_if = /*view*/ + ctx2[1].app.vault.getAbstractFileByPath( + /*change*/ + ctx2[0].vault_path + ); + if (show_if) { + if (if_block) { + if_block.p(ctx2, dirty); + } else { + if_block = create_if_block5(ctx2); + if_block.c(); + if_block.m(div3, t2); + } + } else if (if_block) { + if_block.d(1); + if_block = null; + } + if (dirty & /*change*/ + 1 && t5_value !== (t5_value = /*change*/ + ctx2[0].working_dir + "")) + set_data(t5, t5_value); + if (dirty & /*change*/ + 1 && div4_data_type_value !== (div4_data_type_value = /*change*/ + ctx2[0].working_dir)) { + attr(div4, "data-type", div4_data_type_value); + } + if (dirty & /*side*/ + 8) { + attr( + div6, + "aria-label-position", + /*side*/ + ctx2[3] + ); + } + if (dirty & /*change*/ + 1 && div6_aria_label_value !== (div6_aria_label_value = /*change*/ + ctx2[0].vault_path)) { + attr(div6, "aria-label", div6_aria_label_value); + } + }, + i: noop, + o: noop, + d(detaching) { + if (detaching) { + detach(main); + } + if (if_block) + if_block.d(); + ctx[12](null); + ctx[13](null); + mounted = false; + run_all(dispose); + } + }; +} +function instance5($$self, $$props, $$invalidate) { + let side; + let { change } = $$props; + let { view } = $$props; + let { manager } = $$props; + let buttons = []; + window.setTimeout(() => buttons.forEach((b) => (0, import_obsidian25.setIcon)(b, b.getAttr("data-icon"))), 0); + function hover(event) { + if (app.vault.getAbstractFileByPath(change.vault_path)) { + hoverPreview(event, view, change.vault_path); + } + } + function open(event) { + var _a2; + const file = view.app.vault.getAbstractFileByPath(change.vault_path); + console.log(event); + if (file instanceof import_obsidian25.TFile) { + (_a2 = getNewLeaf(event)) === null || _a2 === void 0 ? void 0 : _a2.openFile(file); + } + } + function stage() { + manager.stage(change.path, false).finally(() => { + dispatchEvent(new CustomEvent("git-refresh")); + }); + } + function showDiff(event) { + var _a2; + (_a2 = getNewLeaf(event)) === null || _a2 === void 0 ? void 0 : _a2.setViewState({ + type: DIFF_VIEW_CONFIG.type, + active: true, + state: { file: change.path, staged: false } + }); + } + function discard() { + const deleteFile = change.working_dir == "U"; + new DiscardModal(view.app, deleteFile, change.vault_path).myOpen().then((shouldDiscard) => { + if (shouldDiscard === true) { + if (deleteFile) { + view.app.vault.adapter.remove(change.vault_path).finally(() => { + dispatchEvent(new CustomEvent("git-refresh")); + }); + } else { + manager.discard(change.path).finally(() => { + dispatchEvent(new CustomEvent("git-refresh")); + }); + } + } + }); + } + function focus_handler(event) { + bubble.call(this, $$self, event); + } + function div_binding($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + buttons[1] = $$value; + $$invalidate(2, buttons); + }); + } + function div1_binding($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + buttons[0] = $$value; + $$invalidate(2, buttons); + }); + } + function div2_binding($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + buttons[2] = $$value; + $$invalidate(2, buttons); + }); + } + $$self.$$set = ($$props2) => { + if ("change" in $$props2) + $$invalidate(0, change = $$props2.change); + if ("view" in $$props2) + $$invalidate(1, view = $$props2.view); + if ("manager" in $$props2) + $$invalidate(9, manager = $$props2.manager); + }; + $$self.$$.update = () => { + if ($$self.$$.dirty & /*view*/ + 2) { + $: + $$invalidate(3, side = view.leaf.getRoot().side == "left" ? "right" : "left"); + } + }; + return [ + change, + view, + buttons, + side, + hover, + open, + stage, + showDiff, + discard, + manager, + focus_handler, + div_binding, + div1_binding, + div2_binding + ]; +} +var FileComponent = class extends SvelteComponent { + constructor(options) { + super(); + init2(this, options, instance5, create_fragment5, safe_not_equal, { change: 0, view: 1, manager: 9 }, add_css4); + } +}; +var fileComponent_default = FileComponent; + +// src/ui/sourceControl/components/pulledFileComponent.svelte +init_polyfill_buffer(); +var import_obsidian26 = require("obsidian"); +function add_css5(target) { + append_styles(target, "svelte-pmbo0n", "main.svelte-pmbo0n .nav-file-title-content.svelte-pmbo0n{display:flex;align-items:center}"); +} +function create_fragment6(ctx) { + let main; + let div2; + let div0; + let t0_value = getDisplayPath( + /*change*/ + ctx[0].vault_path + ) + ""; + let t0; + let t1; + let div1; + let span; + let t2_value = ( + /*change*/ + ctx[0].working_dir + "" + ); + let t2; + let span_data_type_value; + let div2_aria_label_value; + let mounted; + let dispose; + return { + c() { + main = element("main"); + div2 = element("div"); + div0 = element("div"); + t0 = text(t0_value); + t1 = space(); + div1 = element("div"); + span = element("span"); + t2 = text(t2_value); + attr(div0, "class", "tree-item-inner nav-file-title-content svelte-pmbo0n"); + attr(span, "class", "type"); + attr(span, "data-type", span_data_type_value = /*change*/ + ctx[0].working_dir); + attr(div1, "class", "git-tools"); + attr(div2, "class", "tree-item-self is-clickable nav-file-title"); + attr( + div2, + "aria-label-position", + /*side*/ + ctx[1] + ); + attr(div2, "aria-label", div2_aria_label_value = /*change*/ + ctx[0].vault_path); + attr(main, "class", "tree-item nav-file svelte-pmbo0n"); + }, + m(target, anchor) { + insert(target, main, anchor); + append2(main, div2); + append2(div2, div0); + append2(div0, t0); + append2(div2, t1); + append2(div2, div1); + append2(div1, span); + append2(span, t2); + if (!mounted) { + dispose = [ + listen( + main, + "mouseover", + /*hover*/ + ctx[2] + ), + listen(main, "click", stop_propagation( + /*open*/ + ctx[3] + )), + listen(main, "auxclick", stop_propagation( + /*open*/ + ctx[3] + )), + listen( + main, + "focus", + /*focus_handler*/ + ctx[5] + ) + ]; + mounted = true; + } + }, + p(ctx2, [dirty]) { + if (dirty & /*change*/ + 1 && t0_value !== (t0_value = getDisplayPath( + /*change*/ + ctx2[0].vault_path + ) + "")) + set_data(t0, t0_value); + if (dirty & /*change*/ + 1 && t2_value !== (t2_value = /*change*/ + ctx2[0].working_dir + "")) + set_data(t2, t2_value); + if (dirty & /*change*/ + 1 && span_data_type_value !== (span_data_type_value = /*change*/ + ctx2[0].working_dir)) { + attr(span, "data-type", span_data_type_value); + } + if (dirty & /*side*/ + 2) { + attr( + div2, + "aria-label-position", + /*side*/ + ctx2[1] + ); + } + if (dirty & /*change*/ + 1 && div2_aria_label_value !== (div2_aria_label_value = /*change*/ + ctx2[0].vault_path)) { + attr(div2, "aria-label", div2_aria_label_value); + } + }, + i: noop, + o: noop, + d(detaching) { + if (detaching) { + detach(main); + } + mounted = false; + run_all(dispose); + } + }; +} +function instance6($$self, $$props, $$invalidate) { + let side; + let { change } = $$props; + let { view } = $$props; + function hover(event) { + if (app.vault.getAbstractFileByPath(change.vault_path)) { + hoverPreview(event, view, change.vault_path); + } + } + function open(event) { + var _a2; + const file = view.app.vault.getAbstractFileByPath(change.vault_path); + if (file instanceof import_obsidian26.TFile) { + (_a2 = getNewLeaf(event)) === null || _a2 === void 0 ? void 0 : _a2.openFile(file); + } + } + function focus_handler(event) { + bubble.call(this, $$self, event); + } + $$self.$$set = ($$props2) => { + if ("change" in $$props2) + $$invalidate(0, change = $$props2.change); + if ("view" in $$props2) + $$invalidate(4, view = $$props2.view); + }; + $$self.$$.update = () => { + if ($$self.$$.dirty & /*view*/ + 16) { + $: + $$invalidate(1, side = view.leaf.getRoot().side == "left" ? "right" : "left"); + } + }; + return [change, side, hover, open, view, focus_handler]; +} +var PulledFileComponent = class extends SvelteComponent { + constructor(options) { + super(); + init2(this, options, instance6, create_fragment6, safe_not_equal, { change: 0, view: 4 }, add_css5); + } +}; +var pulledFileComponent_default = PulledFileComponent; + +// src/ui/sourceControl/components/stagedFileComponent.svelte +init_polyfill_buffer(); +var import_obsidian27 = require("obsidian"); +function add_css6(target) { + append_styles(target, "svelte-pmbo0n", "main.svelte-pmbo0n .nav-file-title-content.svelte-pmbo0n{display:flex;align-items:center}"); +} +function create_if_block6(ctx) { + let div; + let mounted; + let dispose; + return { + c() { + div = element("div"); + attr(div, "data-icon", "go-to-file"); + attr(div, "aria-label", "Open File"); + attr(div, "class", "clickable-icon"); + }, + m(target, anchor) { + insert(target, div, anchor); + ctx[10](div); + if (!mounted) { + dispose = listen(div, "click", stop_propagation( + /*open*/ + ctx[5] + )); + mounted = true; + } + }, + p: noop, + d(detaching) { + if (detaching) { + detach(div); + } + ctx[10](null); + mounted = false; + dispose(); + } + }; +} +function create_fragment7(ctx) { + let main; + let div5; + let div0; + let t0_value = getDisplayPath( + /*change*/ + ctx[0].vault_path + ) + ""; + let t0; + let t1; + let div4; + let div2; + let show_if = ( + /*view*/ + ctx[1].app.vault.getAbstractFileByPath( + /*change*/ + ctx[0].vault_path + ) + ); + let t2; + let div1; + let t3; + let div3; + let t4_value = ( + /*change*/ + ctx[0].index + "" + ); + let t4; + let div3_data_type_value; + let div5_aria_label_value; + let mounted; + let dispose; + let if_block = show_if && create_if_block6(ctx); + return { + c() { + main = element("main"); + div5 = element("div"); + div0 = element("div"); + t0 = text(t0_value); + t1 = space(); + div4 = element("div"); + div2 = element("div"); + if (if_block) + if_block.c(); + t2 = space(); + div1 = element("div"); + t3 = space(); + div3 = element("div"); + t4 = text(t4_value); + attr(div0, "class", "tree-item-inner nav-file-title-content svelte-pmbo0n"); + attr(div1, "data-icon", "minus"); + attr(div1, "aria-label", "Unstage"); + attr(div1, "class", "clickable-icon"); + attr(div2, "class", "buttons"); + attr(div3, "class", "type"); + attr(div3, "data-type", div3_data_type_value = /*change*/ + ctx[0].index); + attr(div4, "class", "git-tools"); + attr(div5, "class", "tree-item-self is-clickable nav-file-title"); + attr( + div5, + "aria-label-position", + /*side*/ + ctx[3] + ); + attr(div5, "aria-label", div5_aria_label_value = /*change*/ + ctx[0].vault_path); + attr(main, "class", "tree-item nav-file svelte-pmbo0n"); + }, + m(target, anchor) { + insert(target, main, anchor); + append2(main, div5); + append2(div5, div0); + append2(div0, t0); + append2(div5, t1); + append2(div5, div4); + append2(div4, div2); + if (if_block) + if_block.m(div2, null); + append2(div2, t2); + append2(div2, div1); + ctx[11](div1); + append2(div4, t3); + append2(div4, div3); + append2(div3, t4); + if (!mounted) { + dispose = [ + listen(div1, "click", stop_propagation( + /*unstage*/ + ctx[7] + )), + listen( + main, + "mouseover", + /*hover*/ + ctx[4] + ), + listen( + main, + "focus", + /*focus_handler*/ + ctx[9] + ), + listen(main, "click", stop_propagation( + /*showDiff*/ + ctx[6] + )), + listen(main, "auxclick", stop_propagation( + /*showDiff*/ + ctx[6] + )) + ]; + mounted = true; + } + }, + p(ctx2, [dirty]) { + if (dirty & /*change*/ + 1 && t0_value !== (t0_value = getDisplayPath( + /*change*/ + ctx2[0].vault_path + ) + "")) + set_data(t0, t0_value); + if (dirty & /*view, change*/ + 3) + show_if = /*view*/ + ctx2[1].app.vault.getAbstractFileByPath( + /*change*/ + ctx2[0].vault_path + ); + if (show_if) { + if (if_block) { + if_block.p(ctx2, dirty); + } else { + if_block = create_if_block6(ctx2); + if_block.c(); + if_block.m(div2, t2); + } + } else if (if_block) { + if_block.d(1); + if_block = null; + } + if (dirty & /*change*/ + 1 && t4_value !== (t4_value = /*change*/ + ctx2[0].index + "")) + set_data(t4, t4_value); + if (dirty & /*change*/ + 1 && div3_data_type_value !== (div3_data_type_value = /*change*/ + ctx2[0].index)) { + attr(div3, "data-type", div3_data_type_value); + } + if (dirty & /*side*/ + 8) { + attr( + div5, + "aria-label-position", + /*side*/ + ctx2[3] + ); + } + if (dirty & /*change*/ + 1 && div5_aria_label_value !== (div5_aria_label_value = /*change*/ + ctx2[0].vault_path)) { + attr(div5, "aria-label", div5_aria_label_value); + } + }, + i: noop, + o: noop, + d(detaching) { + if (detaching) { + detach(main); + } + if (if_block) + if_block.d(); + ctx[11](null); + mounted = false; + run_all(dispose); + } + }; +} +function instance7($$self, $$props, $$invalidate) { + let formattedPath; + let side; + let { change } = $$props; + let { view } = $$props; + let { manager } = $$props; + let buttons = []; + window.setTimeout(() => buttons.forEach((b) => (0, import_obsidian27.setIcon)(b, b.getAttr("data-icon"), 16)), 0); + function hover(event) { + if (app.vault.getAbstractFileByPath(change.vault_path)) { + hoverPreview(event, view, change.vault_path); + } + } + function open(event) { + var _a2; + const file = view.app.vault.getAbstractFileByPath(change.vault_path); + if (file instanceof import_obsidian27.TFile) { + (_a2 = getNewLeaf(event)) === null || _a2 === void 0 ? void 0 : _a2.openFile(file); + } + } + function showDiff(event) { + var _a2; + (_a2 = getNewLeaf(event)) === null || _a2 === void 0 ? void 0 : _a2.setViewState({ + type: DIFF_VIEW_CONFIG.type, + active: true, + state: { file: change.path, staged: true } + }); + } + function unstage() { + manager.unstage(change.path, false).finally(() => { + dispatchEvent(new CustomEvent("git-refresh")); + }); + } + function focus_handler(event) { + bubble.call(this, $$self, event); + } + function div_binding($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + buttons[1] = $$value; + $$invalidate(2, buttons); + }); + } + function div1_binding($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + buttons[0] = $$value; + $$invalidate(2, buttons); + }); + } + $$self.$$set = ($$props2) => { + if ("change" in $$props2) + $$invalidate(0, change = $$props2.change); + if ("view" in $$props2) + $$invalidate(1, view = $$props2.view); + if ("manager" in $$props2) + $$invalidate(8, manager = $$props2.manager); + }; + $$self.$$.update = () => { + if ($$self.$$.dirty & /*change*/ + 1) { + $: + formattedPath = change.vault_path; + } + if ($$self.$$.dirty & /*view*/ + 2) { + $: + $$invalidate(3, side = view.leaf.getRoot().side == "left" ? "right" : "left"); + } + }; + return [ + change, + view, + buttons, + side, + hover, + open, + showDiff, + unstage, + manager, + focus_handler, + div_binding, + div1_binding + ]; +} +var StagedFileComponent = class extends SvelteComponent { + constructor(options) { + super(); + init2(this, options, instance7, create_fragment7, safe_not_equal, { change: 0, view: 1, manager: 8 }, add_css6); + } +}; +var stagedFileComponent_default = StagedFileComponent; + +// src/ui/sourceControl/components/treeComponent.svelte +init_polyfill_buffer(); +function add_css7(target) { + append_styles(target, "svelte-1lnl15d", "main.svelte-1lnl15d .nav-folder-title-content.svelte-1lnl15d{display:flex;align-items:center}"); +} +function get_each_context4(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[15] = list[i]; + return child_ctx; +} +function create_else_block3(ctx) { + let div7; + let div6; + let div0; + let t0; + let div1; + let t1; + let div2; + let t2_value = ( + /*entity*/ + ctx[15].title + "" + ); + let t2; + let t3; + let div5; + let div4; + let t4; + let div3; + let div6_aria_label_value; + let t5; + let t6; + let current; + let mounted; + let dispose; + function select_block_type_2(ctx2, dirty) { + if ( + /*fileType*/ + ctx2[3] == 0 /* staged */ + ) + return create_if_block_5; + return create_else_block_1; + } + let current_block_type = select_block_type_2(ctx, -1); + let if_block0 = current_block_type(ctx); + let if_block1 = !/*closed*/ + ctx[5][ + /*entity*/ + ctx[15].title + ] && create_if_block_4(ctx); + function click_handler_3() { + return ( + /*click_handler_3*/ + ctx[14]( + /*entity*/ + ctx[15] + ) + ); + } + return { + c() { + div7 = element("div"); + div6 = element("div"); + div0 = element("div"); + t0 = space(); + div1 = element("div"); + div1.innerHTML = ``; + t1 = space(); + div2 = element("div"); + t2 = text(t2_value); + t3 = space(); + div5 = element("div"); + div4 = element("div"); + if_block0.c(); + t4 = space(); + div3 = element("div"); + t5 = space(); + if (if_block1) + if_block1.c(); + t6 = space(); + attr(div0, "data-icon", "folder"); + set_style(div0, "padding-right", "5px"); + set_style(div0, "display", "flex"); + attr(div1, "class", "tree-item-icon nav-folder-collapse-indicator collapse-icon"); + attr(div2, "class", "tree-item-inner nav-folder-title-content svelte-1lnl15d"); + set_style(div3, "width", "11px"); + attr(div4, "class", "buttons"); + attr(div5, "class", "git-tools"); + attr(div6, "class", "tree-item-self is-clickable nav-folder-title"); + attr( + div6, + "aria-label-position", + /*side*/ + ctx[6] + ); + attr(div6, "aria-label", div6_aria_label_value = /*entity*/ + ctx[15].vaultPath); + attr(div7, "class", "tree-item nav-folder"); + toggle_class( + div7, + "is-collapsed", + /*closed*/ + ctx[5][ + /*entity*/ + ctx[15].title + ] + ); + }, + m(target, anchor) { + insert(target, div7, anchor); + append2(div7, div6); + append2(div6, div0); + append2(div6, t0); + append2(div6, div1); + append2(div6, t1); + append2(div6, div2); + append2(div2, t2); + append2(div6, t3); + append2(div6, div5); + append2(div5, div4); + if_block0.m(div4, null); + append2(div4, t4); + append2(div4, div3); + append2(div7, t5); + if (if_block1) + if_block1.m(div7, null); + append2(div7, t6); + current = true; + if (!mounted) { + dispose = listen(div7, "click", click_handler_3); + mounted = true; + } + }, + p(new_ctx, dirty) { + ctx = new_ctx; + if ((!current || dirty & /*hierarchy*/ + 1) && t2_value !== (t2_value = /*entity*/ + ctx[15].title + "")) + set_data(t2, t2_value); + if (current_block_type === (current_block_type = select_block_type_2(ctx, dirty)) && if_block0) { + if_block0.p(ctx, dirty); + } else { + if_block0.d(1); + if_block0 = current_block_type(ctx); + if (if_block0) { + if_block0.c(); + if_block0.m(div4, t4); + } + } + if (!current || dirty & /*side*/ + 64) { + attr( + div6, + "aria-label-position", + /*side*/ + ctx[6] + ); + } + if (!current || dirty & /*hierarchy*/ + 1 && div6_aria_label_value !== (div6_aria_label_value = /*entity*/ + ctx[15].vaultPath)) { + attr(div6, "aria-label", div6_aria_label_value); + } + if (!/*closed*/ + ctx[5][ + /*entity*/ + ctx[15].title + ]) { + if (if_block1) { + if_block1.p(ctx, dirty); + if (dirty & /*closed, hierarchy*/ + 33) { + transition_in(if_block1, 1); + } + } else { + if_block1 = create_if_block_4(ctx); + if_block1.c(); + transition_in(if_block1, 1); + if_block1.m(div7, t6); + } + } else if (if_block1) { + group_outros(); + transition_out(if_block1, 1, 1, () => { + if_block1 = null; + }); + check_outros(); + } + if (!current || dirty & /*closed, hierarchy*/ + 33) { + toggle_class( + div7, + "is-collapsed", + /*closed*/ + ctx[5][ + /*entity*/ + ctx[15].title + ] + ); + } + }, + i(local) { + if (current) + return; + transition_in(if_block1); + current = true; + }, + o(local) { + transition_out(if_block1); + current = false; + }, + d(detaching) { + if (detaching) { + detach(div7); + } + if_block0.d(); + if (if_block1) + if_block1.d(); + mounted = false; + dispose(); + } + }; +} +function create_if_block7(ctx) { + let div; + let current_block_type_index; + let if_block; + let t; + let current; + const if_block_creators = [create_if_block_13, create_if_block_22, create_if_block_3]; + const if_blocks = []; + function select_block_type_1(ctx2, dirty) { + if ( + /*fileType*/ + ctx2[3] == 0 /* staged */ + ) + return 0; + if ( + /*fileType*/ + ctx2[3] == 1 /* changed */ + ) + return 1; + if ( + /*fileType*/ + ctx2[3] == 2 /* pulled */ + ) + return 2; + return -1; + } + if (~(current_block_type_index = select_block_type_1(ctx, -1))) { + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx); + } + return { + c() { + div = element("div"); + if (if_block) + if_block.c(); + t = space(); + }, + m(target, anchor) { + insert(target, div, anchor); + if (~current_block_type_index) { + if_blocks[current_block_type_index].m(div, null); + } + append2(div, t); + current = true; + }, + p(ctx2, dirty) { + let previous_block_index = current_block_type_index; + current_block_type_index = select_block_type_1(ctx2, dirty); + if (current_block_type_index === previous_block_index) { + if (~current_block_type_index) { + if_blocks[current_block_type_index].p(ctx2, dirty); + } + } else { + if (if_block) { + group_outros(); + transition_out(if_blocks[previous_block_index], 1, 1, () => { + if_blocks[previous_block_index] = null; + }); + check_outros(); + } + if (~current_block_type_index) { + if_block = if_blocks[current_block_type_index]; + if (!if_block) { + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2); + if_block.c(); + } else { + if_block.p(ctx2, dirty); + } + transition_in(if_block, 1); + if_block.m(div, t); + } else { + if_block = null; + } + } + }, + i(local) { + if (current) + return; + transition_in(if_block); + current = true; + }, + o(local) { + transition_out(if_block); + current = false; + }, + d(detaching) { + if (detaching) { + detach(div); + } + if (~current_block_type_index) { + if_blocks[current_block_type_index].d(); + } + } + }; +} +function create_else_block_1(ctx) { + let div0; + let t; + let div1; + let mounted; + let dispose; + function click_handler_1() { + return ( + /*click_handler_1*/ + ctx[12]( + /*entity*/ + ctx[15] + ) + ); + } + function click_handler_2() { + return ( + /*click_handler_2*/ + ctx[13]( + /*entity*/ + ctx[15] + ) + ); + } + return { + c() { + div0 = element("div"); + div0.innerHTML = ``; + t = space(); + div1 = element("div"); + div1.innerHTML = ``; + attr(div0, "data-icon", "undo"); + attr(div0, "aria-label", "Discard"); + attr(div0, "class", "clickable-icon"); + attr(div1, "data-icon", "plus"); + attr(div1, "aria-label", "Stage"); + attr(div1, "class", "clickable-icon"); + }, + m(target, anchor) { + insert(target, div0, anchor); + insert(target, t, anchor); + insert(target, div1, anchor); + if (!mounted) { + dispose = [ + listen(div0, "click", stop_propagation(click_handler_1)), + listen(div1, "click", stop_propagation(click_handler_2)) + ]; + mounted = true; + } + }, + p(new_ctx, dirty) { + ctx = new_ctx; + }, + d(detaching) { + if (detaching) { + detach(div0); + detach(t); + detach(div1); + } + mounted = false; + run_all(dispose); + } + }; +} +function create_if_block_5(ctx) { + let div; + let mounted; + let dispose; + function click_handler() { + return ( + /*click_handler*/ + ctx[11]( + /*entity*/ + ctx[15] + ) + ); + } + return { + c() { + div = element("div"); + div.innerHTML = ``; + attr(div, "data-icon", "minus"); + attr(div, "aria-label", "Unstage"); + attr(div, "class", "clickable-icon"); + }, + m(target, anchor) { + insert(target, div, anchor); + if (!mounted) { + dispose = listen(div, "click", stop_propagation(click_handler)); + mounted = true; + } + }, + p(new_ctx, dirty) { + ctx = new_ctx; + }, + d(detaching) { + if (detaching) { + detach(div); + } + mounted = false; + dispose(); + } + }; +} +function create_if_block_4(ctx) { + let div; + let treecomponent; + let div_transition; + let current; + treecomponent = new TreeComponent({ + props: { + hierarchy: ( + /*entity*/ + ctx[15] + ), + plugin: ( + /*plugin*/ + ctx[1] + ), + view: ( + /*view*/ + ctx[2] + ), + fileType: ( + /*fileType*/ + ctx[3] + ) + } + }); + return { + c() { + div = element("div"); + create_component(treecomponent.$$.fragment); + attr(div, "class", "tree-item-children nav-folder-children"); + }, + m(target, anchor) { + insert(target, div, anchor); + mount_component(treecomponent, div, null); + current = true; + }, + p(ctx2, dirty) { + const treecomponent_changes = {}; + if (dirty & /*hierarchy*/ + 1) + treecomponent_changes.hierarchy = /*entity*/ + ctx2[15]; + if (dirty & /*plugin*/ + 2) + treecomponent_changes.plugin = /*plugin*/ + ctx2[1]; + if (dirty & /*view*/ + 4) + treecomponent_changes.view = /*view*/ + ctx2[2]; + if (dirty & /*fileType*/ + 8) + treecomponent_changes.fileType = /*fileType*/ + ctx2[3]; + treecomponent.$set(treecomponent_changes); + }, + i(local) { + if (current) + return; + transition_in(treecomponent.$$.fragment, local); + if (local) { + add_render_callback(() => { + if (!current) + return; + if (!div_transition) + div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, true); + div_transition.run(1); + }); + } + current = true; + }, + o(local) { + transition_out(treecomponent.$$.fragment, local); + if (local) { + if (!div_transition) + div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, false); + div_transition.run(0); + } + current = false; + }, + d(detaching) { + if (detaching) { + detach(div); + } + destroy_component(treecomponent); + if (detaching && div_transition) + div_transition.end(); + } + }; +} +function create_if_block_3(ctx) { + let pulledfilecomponent; + let current; + pulledfilecomponent = new pulledFileComponent_default({ + props: { + change: ( + /*entity*/ + ctx[15].data + ), + view: ( + /*view*/ + ctx[2] + ) + } + }); + return { + c() { + create_component(pulledfilecomponent.$$.fragment); + }, + m(target, anchor) { + mount_component(pulledfilecomponent, target, anchor); + current = true; + }, + p(ctx2, dirty) { + const pulledfilecomponent_changes = {}; + if (dirty & /*hierarchy*/ + 1) + pulledfilecomponent_changes.change = /*entity*/ + ctx2[15].data; + if (dirty & /*view*/ + 4) + pulledfilecomponent_changes.view = /*view*/ + ctx2[2]; + pulledfilecomponent.$set(pulledfilecomponent_changes); + }, + i(local) { + if (current) + return; + transition_in(pulledfilecomponent.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(pulledfilecomponent.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(pulledfilecomponent, detaching); + } + }; +} +function create_if_block_22(ctx) { + let filecomponent; + let current; + filecomponent = new fileComponent_default({ + props: { + change: ( + /*entity*/ + ctx[15].data + ), + manager: ( + /*plugin*/ + ctx[1].gitManager + ), + view: ( + /*view*/ + ctx[2] + ) + } + }); + return { + c() { + create_component(filecomponent.$$.fragment); + }, + m(target, anchor) { + mount_component(filecomponent, target, anchor); + current = true; + }, + p(ctx2, dirty) { + const filecomponent_changes = {}; + if (dirty & /*hierarchy*/ + 1) + filecomponent_changes.change = /*entity*/ + ctx2[15].data; + if (dirty & /*plugin*/ + 2) + filecomponent_changes.manager = /*plugin*/ + ctx2[1].gitManager; + if (dirty & /*view*/ + 4) + filecomponent_changes.view = /*view*/ + ctx2[2]; + filecomponent.$set(filecomponent_changes); + }, + i(local) { + if (current) + return; + transition_in(filecomponent.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(filecomponent.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(filecomponent, detaching); + } + }; +} +function create_if_block_13(ctx) { + let stagedfilecomponent; + let current; + stagedfilecomponent = new stagedFileComponent_default({ + props: { + change: ( + /*entity*/ + ctx[15].data + ), + manager: ( + /*plugin*/ + ctx[1].gitManager + ), + view: ( + /*view*/ + ctx[2] + ) + } + }); + return { + c() { + create_component(stagedfilecomponent.$$.fragment); + }, + m(target, anchor) { + mount_component(stagedfilecomponent, target, anchor); + current = true; + }, + p(ctx2, dirty) { + const stagedfilecomponent_changes = {}; + if (dirty & /*hierarchy*/ + 1) + stagedfilecomponent_changes.change = /*entity*/ + ctx2[15].data; + if (dirty & /*plugin*/ + 2) + stagedfilecomponent_changes.manager = /*plugin*/ + ctx2[1].gitManager; + if (dirty & /*view*/ + 4) + stagedfilecomponent_changes.view = /*view*/ + ctx2[2]; + stagedfilecomponent.$set(stagedfilecomponent_changes); + }, + i(local) { + if (current) + return; + transition_in(stagedfilecomponent.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(stagedfilecomponent.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(stagedfilecomponent, detaching); + } + }; +} +function create_each_block4(ctx) { + let current_block_type_index; + let if_block; + let if_block_anchor; + let current; + const if_block_creators = [create_if_block7, create_else_block3]; + const if_blocks = []; + function select_block_type(ctx2, dirty) { + if ( + /*entity*/ + ctx2[15].data + ) + return 0; + return 1; + } + current_block_type_index = select_block_type(ctx, -1); + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx); + return { + c() { + if_block.c(); + if_block_anchor = empty(); + }, + m(target, anchor) { + if_blocks[current_block_type_index].m(target, anchor); + insert(target, if_block_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + let previous_block_index = current_block_type_index; + current_block_type_index = select_block_type(ctx2, dirty); + if (current_block_type_index === previous_block_index) { + if_blocks[current_block_type_index].p(ctx2, dirty); + } else { + group_outros(); + transition_out(if_blocks[previous_block_index], 1, 1, () => { + if_blocks[previous_block_index] = null; + }); + check_outros(); + if_block = if_blocks[current_block_type_index]; + if (!if_block) { + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2); + if_block.c(); + } else { + if_block.p(ctx2, dirty); + } + transition_in(if_block, 1); + if_block.m(if_block_anchor.parentNode, if_block_anchor); + } + }, + i(local) { + if (current) + return; + transition_in(if_block); + current = true; + }, + o(local) { + transition_out(if_block); + current = false; + }, + d(detaching) { + if (detaching) { + detach(if_block_anchor); + } + if_blocks[current_block_type_index].d(detaching); + } + }; +} +function create_fragment8(ctx) { + let main; + let current; + let each_value = ensure_array_like( + /*hierarchy*/ + ctx[0].children + ); + let each_blocks = []; + for (let i = 0; i < each_value.length; i += 1) { + each_blocks[i] = create_each_block4(get_each_context4(ctx, each_value, i)); + } + const out = (i) => transition_out(each_blocks[i], 1, 1, () => { + each_blocks[i] = null; + }); + return { + c() { + main = element("main"); + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + attr(main, "class", "svelte-1lnl15d"); + toggle_class( + main, + "topLevel", + /*topLevel*/ + ctx[4] + ); + }, + m(target, anchor) { + insert(target, main, anchor); + for (let i = 0; i < each_blocks.length; i += 1) { + if (each_blocks[i]) { + each_blocks[i].m(main, null); + } + } + current = true; + }, + p(ctx2, [dirty]) { + if (dirty & /*hierarchy, plugin, view, fileType, FileType, closed, fold, side, unstage, stage, discard*/ + 2031) { + each_value = ensure_array_like( + /*hierarchy*/ + ctx2[0].children + ); + let i; + for (i = 0; i < each_value.length; i += 1) { + const child_ctx = get_each_context4(ctx2, each_value, i); + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + transition_in(each_blocks[i], 1); + } else { + each_blocks[i] = create_each_block4(child_ctx); + each_blocks[i].c(); + transition_in(each_blocks[i], 1); + each_blocks[i].m(main, null); + } + } + group_outros(); + for (i = each_value.length; i < each_blocks.length; i += 1) { + out(i); + } + check_outros(); + } + if (!current || dirty & /*topLevel*/ + 16) { + toggle_class( + main, + "topLevel", + /*topLevel*/ + ctx2[4] + ); + } + }, + i(local) { + if (current) + return; + for (let i = 0; i < each_value.length; i += 1) { + transition_in(each_blocks[i]); + } + current = true; + }, + o(local) { + each_blocks = each_blocks.filter(Boolean); + for (let i = 0; i < each_blocks.length; i += 1) { + transition_out(each_blocks[i]); + } + current = false; + }, + d(detaching) { + if (detaching) { + detach(main); + } + destroy_each(each_blocks, detaching); + } + }; +} +function instance8($$self, $$props, $$invalidate) { + let side; + let { hierarchy } = $$props; + let { plugin } = $$props; + let { view } = $$props; + let { fileType } = $$props; + let { topLevel = false } = $$props; + const closed = {}; + function stage(path2) { + plugin.gitManager.stageAll({ dir: path2 }).finally(() => { + dispatchEvent(new CustomEvent("git-refresh")); + }); + } + function unstage(path2) { + plugin.gitManager.unstageAll({ dir: path2 }).finally(() => { + dispatchEvent(new CustomEvent("git-refresh")); + }); + } + function discard(item) { + new DiscardModal(view.app, false, item.vaultPath).myOpen().then((shouldDiscard) => { + if (shouldDiscard === true) { + plugin.gitManager.discardAll({ + dir: item.path, + status: plugin.cachedStatus + }).finally(() => { + dispatchEvent(new CustomEvent("git-refresh")); + }); + } + }); + } + function fold(item) { + $$invalidate(5, closed[item.title] = !closed[item.title], closed); + } + const click_handler = (entity) => unstage(entity.path); + const click_handler_1 = (entity) => discard(entity); + const click_handler_2 = (entity) => stage(entity.path); + const click_handler_3 = (entity) => fold(entity); + $$self.$$set = ($$props2) => { + if ("hierarchy" in $$props2) + $$invalidate(0, hierarchy = $$props2.hierarchy); + if ("plugin" in $$props2) + $$invalidate(1, plugin = $$props2.plugin); + if ("view" in $$props2) + $$invalidate(2, view = $$props2.view); + if ("fileType" in $$props2) + $$invalidate(3, fileType = $$props2.fileType); + if ("topLevel" in $$props2) + $$invalidate(4, topLevel = $$props2.topLevel); + }; + $$self.$$.update = () => { + if ($$self.$$.dirty & /*view*/ + 4) { + $: + $$invalidate(6, side = view.leaf.getRoot().side == "left" ? "right" : "left"); + } + }; + return [ + hierarchy, + plugin, + view, + fileType, + topLevel, + closed, + side, + stage, + unstage, + discard, + fold, + click_handler, + click_handler_1, + click_handler_2, + click_handler_3 + ]; +} +var TreeComponent = class extends SvelteComponent { + constructor(options) { + super(); + init2( + this, + options, + instance8, + create_fragment8, + safe_not_equal, + { + hierarchy: 0, + plugin: 1, + view: 2, + fileType: 3, + topLevel: 4 + }, + add_css7 + ); + } +}; +var treeComponent_default = TreeComponent; + +// src/ui/sourceControl/sourceControl.svelte +function add_css8(target) { + append_styles(target, "svelte-48bivb", `.commit-msg-input.svelte-48bivb.svelte-48bivb{width:100%;overflow:hidden;resize:none;padding:7px 5px;background-color:var(--background-modifier-form-field)}.git-commit-msg.svelte-48bivb.svelte-48bivb{position:relative;padding:0;width:calc(100% - var(--size-4-8));margin:4px auto}main.svelte-48bivb .git-tools .files-count.svelte-48bivb{padding-left:var(--size-2-1);width:11px;display:flex;align-items:center;justify-content:center}.git-commit-msg-clear-button.svelte-48bivb.svelte-48bivb{position:absolute;background:transparent;border-radius:50%;color:var(--search-clear-button-color);cursor:var(--cursor);top:-4px;right:2px;bottom:0px;line-height:0;height:var(--input-height);width:28px;margin:auto;padding:0 0;text-align:center;display:flex;justify-content:center;align-items:center;transition:color 0.15s ease-in-out}.git-commit-msg-clear-button.svelte-48bivb.svelte-48bivb:after{content:"";height:var(--search-clear-button-size);width:var(--search-clear-button-size);display:block;background-color:currentColor;-webkit-mask-image:url("data:image/svg+xml,");-webkit-mask-repeat:no-repeat}`); +} +function get_each_context5(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[40] = list[i]; + return child_ctx; +} +function get_each_context_1(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[40] = list[i]; + return child_ctx; +} +function get_each_context_2(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[45] = list[i]; + return child_ctx; +} +function create_if_block_8(ctx) { + let div; + let div_aria_label_value; + let mounted; + let dispose; + return { + c() { + div = element("div"); + attr(div, "class", "git-commit-msg-clear-button svelte-48bivb"); + attr(div, "aria-label", div_aria_label_value = "Clear"); + }, + m(target, anchor) { + insert(target, div, anchor); + if (!mounted) { + dispose = listen( + div, + "click", + /*click_handler_1*/ + ctx[33] + ); + mounted = true; + } + }, + p: noop, + d(detaching) { + if (detaching) { + detach(div); + } + mounted = false; + dispose(); + } + }; +} +function create_if_block8(ctx) { + let div18; + let div17; + let div7; + let div6; + let div0; + let t0; + let div1; + let t2; + let div5; + let div3; + let div2; + let t3; + let div4; + let t4_value = ( + /*status*/ + ctx[6].staged.length + "" + ); + let t4; + let t5; + let t6; + let div16; + let div15; + let div8; + let t7; + let div9; + let t9; + let div14; + let div12; + let div10; + let t10; + let div11; + let t11; + let div13; + let t12_value = ( + /*status*/ + ctx[6].changed.length + "" + ); + let t12; + let t13; + let t14; + let current; + let mounted; + let dispose; + let if_block0 = ( + /*stagedOpen*/ + ctx[13] && create_if_block_6(ctx) + ); + let if_block1 = ( + /*changesOpen*/ + ctx[12] && create_if_block_42(ctx) + ); + let if_block2 = ( + /*lastPulledFiles*/ + ctx[7].length > 0 && create_if_block_14(ctx) + ); + return { + c() { + div18 = element("div"); + div17 = element("div"); + div7 = element("div"); + div6 = element("div"); + div0 = element("div"); + div0.innerHTML = ``; + t0 = space(); + div1 = element("div"); + div1.textContent = "Staged Changes"; + t2 = space(); + div5 = element("div"); + div3 = element("div"); + div2 = element("div"); + div2.innerHTML = ``; + t3 = space(); + div4 = element("div"); + t4 = text(t4_value); + t5 = space(); + if (if_block0) + if_block0.c(); + t6 = space(); + div16 = element("div"); + div15 = element("div"); + div8 = element("div"); + div8.innerHTML = ``; + t7 = space(); + div9 = element("div"); + div9.textContent = "Changes"; + t9 = space(); + div14 = element("div"); + div12 = element("div"); + div10 = element("div"); + div10.innerHTML = ``; + t10 = space(); + div11 = element("div"); + div11.innerHTML = ``; + t11 = space(); + div13 = element("div"); + t12 = text(t12_value); + t13 = space(); + if (if_block1) + if_block1.c(); + t14 = space(); + if (if_block2) + if_block2.c(); + attr(div0, "class", "tree-item-icon nav-folder-collapse-indicator collapse-icon"); + attr(div1, "class", "tree-item-inner nav-folder-title-content"); + attr(div2, "data-icon", "minus"); + attr(div2, "aria-label", "Unstage"); + attr(div2, "class", "clickable-icon"); + attr(div3, "class", "buttons"); + attr(div4, "class", "files-count svelte-48bivb"); + attr(div5, "class", "git-tools"); + attr(div6, "class", "tree-item-self is-clickable nav-folder-title"); + attr(div7, "class", "staged tree-item nav-folder"); + toggle_class(div7, "is-collapsed", !/*stagedOpen*/ + ctx[13]); + attr(div8, "class", "tree-item-icon nav-folder-collapse-indicator collapse-icon"); + attr(div9, "class", "tree-item-inner nav-folder-title-content"); + attr(div10, "data-icon", "undo"); + attr(div10, "aria-label", "Discard"); + attr(div10, "class", "clickable-icon"); + attr(div11, "data-icon", "plus"); + attr(div11, "aria-label", "Stage"); + attr(div11, "class", "clickable-icon"); + attr(div12, "class", "buttons"); + attr(div13, "class", "files-count svelte-48bivb"); + attr(div14, "class", "git-tools"); + attr(div15, "class", "tree-item-self is-clickable nav-folder-title"); + attr(div16, "class", "changes nav-folder"); + toggle_class(div16, "is-collapsed", !/*changesOpen*/ + ctx[12]); + attr(div17, "class", "tree-item-children nav-folder-children"); + attr(div18, "class", "tree-item nav-folder mod-root"); + }, + m(target, anchor) { + insert(target, div18, anchor); + append2(div18, div17); + append2(div17, div7); + append2(div7, div6); + append2(div6, div0); + append2(div6, t0); + append2(div6, div1); + append2(div6, t2); + append2(div6, div5); + append2(div5, div3); + append2(div3, div2); + ctx[34](div2); + append2(div5, t3); + append2(div5, div4); + append2(div4, t4); + append2(div7, t5); + if (if_block0) + if_block0.m(div7, null); + append2(div17, t6); + append2(div17, div16); + append2(div16, div15); + append2(div15, div8); + append2(div15, t7); + append2(div15, div9); + append2(div15, t9); + append2(div15, div14); + append2(div14, div12); + append2(div12, div10); + append2(div12, t10); + append2(div12, div11); + ctx[36](div11); + append2(div14, t11); + append2(div14, div13); + append2(div13, t12); + append2(div16, t13); + if (if_block1) + if_block1.m(div16, null); + append2(div17, t14); + if (if_block2) + if_block2.m(div17, null); + current = true; + if (!mounted) { + dispose = [ + listen(div2, "click", stop_propagation( + /*unstageAll*/ + ctx[19] + )), + listen( + div6, + "click", + /*click_handler_2*/ + ctx[35] + ), + listen(div10, "click", stop_propagation( + /*discard*/ + ctx[22] + )), + listen(div11, "click", stop_propagation( + /*stageAll*/ + ctx[18] + )), + listen( + div15, + "click", + /*click_handler_3*/ + ctx[37] + ) + ]; + mounted = true; + } + }, + p(ctx2, dirty) { + if ((!current || dirty[0] & /*status*/ + 64) && t4_value !== (t4_value = /*status*/ + ctx2[6].staged.length + "")) + set_data(t4, t4_value); + if ( + /*stagedOpen*/ + ctx2[13] + ) { + if (if_block0) { + if_block0.p(ctx2, dirty); + if (dirty[0] & /*stagedOpen*/ + 8192) { + transition_in(if_block0, 1); + } + } else { + if_block0 = create_if_block_6(ctx2); + if_block0.c(); + transition_in(if_block0, 1); + if_block0.m(div7, null); + } + } else if (if_block0) { + group_outros(); + transition_out(if_block0, 1, 1, () => { + if_block0 = null; + }); + check_outros(); + } + if (!current || dirty[0] & /*stagedOpen*/ + 8192) { + toggle_class(div7, "is-collapsed", !/*stagedOpen*/ + ctx2[13]); + } + if ((!current || dirty[0] & /*status*/ + 64) && t12_value !== (t12_value = /*status*/ + ctx2[6].changed.length + "")) + set_data(t12, t12_value); + if ( + /*changesOpen*/ + ctx2[12] + ) { + if (if_block1) { + if_block1.p(ctx2, dirty); + if (dirty[0] & /*changesOpen*/ + 4096) { + transition_in(if_block1, 1); + } + } else { + if_block1 = create_if_block_42(ctx2); + if_block1.c(); + transition_in(if_block1, 1); + if_block1.m(div16, null); + } + } else if (if_block1) { + group_outros(); + transition_out(if_block1, 1, 1, () => { + if_block1 = null; + }); + check_outros(); + } + if (!current || dirty[0] & /*changesOpen*/ + 4096) { + toggle_class(div16, "is-collapsed", !/*changesOpen*/ + ctx2[12]); + } + if ( + /*lastPulledFiles*/ + ctx2[7].length > 0 + ) { + if (if_block2) { + if_block2.p(ctx2, dirty); + if (dirty[0] & /*lastPulledFiles*/ + 128) { + transition_in(if_block2, 1); + } + } else { + if_block2 = create_if_block_14(ctx2); + if_block2.c(); + transition_in(if_block2, 1); + if_block2.m(div17, null); + } + } else if (if_block2) { + group_outros(); + transition_out(if_block2, 1, 1, () => { + if_block2 = null; + }); + check_outros(); + } + }, + i(local) { + if (current) + return; + transition_in(if_block0); + transition_in(if_block1); + transition_in(if_block2); + current = true; + }, + o(local) { + transition_out(if_block0); + transition_out(if_block1); + transition_out(if_block2); + current = false; + }, + d(detaching) { + if (detaching) { + detach(div18); + } + ctx[34](null); + if (if_block0) + if_block0.d(); + ctx[36](null); + if (if_block1) + if_block1.d(); + if (if_block2) + if_block2.d(); + mounted = false; + run_all(dispose); + } + }; +} +function create_if_block_6(ctx) { + let div; + let current_block_type_index; + let if_block; + let div_transition; + let current; + const if_block_creators = [create_if_block_7, create_else_block_2]; + const if_blocks = []; + function select_block_type(ctx2, dirty) { + if ( + /*showTree*/ + ctx2[3] + ) + return 0; + return 1; + } + current_block_type_index = select_block_type(ctx, [-1, -1]); + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx); + return { + c() { + div = element("div"); + if_block.c(); + attr(div, "class", "tree-item-children nav-folder-children"); + }, + m(target, anchor) { + insert(target, div, anchor); + if_blocks[current_block_type_index].m(div, null); + current = true; + }, + p(ctx2, dirty) { + let previous_block_index = current_block_type_index; + current_block_type_index = select_block_type(ctx2, dirty); + if (current_block_type_index === previous_block_index) { + if_blocks[current_block_type_index].p(ctx2, dirty); + } else { + group_outros(); + transition_out(if_blocks[previous_block_index], 1, 1, () => { + if_blocks[previous_block_index] = null; + }); + check_outros(); + if_block = if_blocks[current_block_type_index]; + if (!if_block) { + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2); + if_block.c(); + } else { + if_block.p(ctx2, dirty); + } + transition_in(if_block, 1); + if_block.m(div, null); + } + }, + i(local) { + if (current) + return; + transition_in(if_block); + if (local) { + add_render_callback(() => { + if (!current) + return; + if (!div_transition) + div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, true); + div_transition.run(1); + }); + } + current = true; + }, + o(local) { + transition_out(if_block); + if (local) { + if (!div_transition) + div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, false); + div_transition.run(0); + } + current = false; + }, + d(detaching) { + if (detaching) { + detach(div); + } + if_blocks[current_block_type_index].d(); + if (detaching && div_transition) + div_transition.end(); + } + }; +} +function create_else_block_2(ctx) { + let each_1_anchor; + let current; + let each_value_2 = ensure_array_like( + /*status*/ + ctx[6].staged + ); + let each_blocks = []; + for (let i = 0; i < each_value_2.length; i += 1) { + each_blocks[i] = create_each_block_2(get_each_context_2(ctx, each_value_2, i)); + } + const out = (i) => transition_out(each_blocks[i], 1, 1, () => { + each_blocks[i] = null; + }); + return { + c() { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + each_1_anchor = empty(); + }, + m(target, anchor) { + for (let i = 0; i < each_blocks.length; i += 1) { + if (each_blocks[i]) { + each_blocks[i].m(target, anchor); + } + } + insert(target, each_1_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + if (dirty[0] & /*status, view, plugin*/ + 67) { + each_value_2 = ensure_array_like( + /*status*/ + ctx2[6].staged + ); + let i; + for (i = 0; i < each_value_2.length; i += 1) { + const child_ctx = get_each_context_2(ctx2, each_value_2, i); + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + transition_in(each_blocks[i], 1); + } else { + each_blocks[i] = create_each_block_2(child_ctx); + each_blocks[i].c(); + transition_in(each_blocks[i], 1); + each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor); + } + } + group_outros(); + for (i = each_value_2.length; i < each_blocks.length; i += 1) { + out(i); + } + check_outros(); + } + }, + i(local) { + if (current) + return; + for (let i = 0; i < each_value_2.length; i += 1) { + transition_in(each_blocks[i]); + } + current = true; + }, + o(local) { + each_blocks = each_blocks.filter(Boolean); + for (let i = 0; i < each_blocks.length; i += 1) { + transition_out(each_blocks[i]); + } + current = false; + }, + d(detaching) { + if (detaching) { + detach(each_1_anchor); + } + destroy_each(each_blocks, detaching); + } + }; +} +function create_if_block_7(ctx) { + let treecomponent; + let current; + treecomponent = new treeComponent_default({ + props: { + hierarchy: ( + /*stagedHierarchy*/ + ctx[10] + ), + plugin: ( + /*plugin*/ + ctx[0] + ), + view: ( + /*view*/ + ctx[1] + ), + fileType: 0 /* staged */, + topLevel: true + } + }); + return { + c() { + create_component(treecomponent.$$.fragment); + }, + m(target, anchor) { + mount_component(treecomponent, target, anchor); + current = true; + }, + p(ctx2, dirty) { + const treecomponent_changes = {}; + if (dirty[0] & /*stagedHierarchy*/ + 1024) + treecomponent_changes.hierarchy = /*stagedHierarchy*/ + ctx2[10]; + if (dirty[0] & /*plugin*/ + 1) + treecomponent_changes.plugin = /*plugin*/ + ctx2[0]; + if (dirty[0] & /*view*/ + 2) + treecomponent_changes.view = /*view*/ + ctx2[1]; + treecomponent.$set(treecomponent_changes); + }, + i(local) { + if (current) + return; + transition_in(treecomponent.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(treecomponent.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(treecomponent, detaching); + } + }; +} +function create_each_block_2(ctx) { + let stagedfilecomponent; + let current; + stagedfilecomponent = new stagedFileComponent_default({ + props: { + change: ( + /*stagedFile*/ + ctx[45] + ), + view: ( + /*view*/ + ctx[1] + ), + manager: ( + /*plugin*/ + ctx[0].gitManager + ) + } + }); + return { + c() { + create_component(stagedfilecomponent.$$.fragment); + }, + m(target, anchor) { + mount_component(stagedfilecomponent, target, anchor); + current = true; + }, + p(ctx2, dirty) { + const stagedfilecomponent_changes = {}; + if (dirty[0] & /*status*/ + 64) + stagedfilecomponent_changes.change = /*stagedFile*/ + ctx2[45]; + if (dirty[0] & /*view*/ + 2) + stagedfilecomponent_changes.view = /*view*/ + ctx2[1]; + if (dirty[0] & /*plugin*/ + 1) + stagedfilecomponent_changes.manager = /*plugin*/ + ctx2[0].gitManager; + stagedfilecomponent.$set(stagedfilecomponent_changes); + }, + i(local) { + if (current) + return; + transition_in(stagedfilecomponent.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(stagedfilecomponent.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(stagedfilecomponent, detaching); + } + }; +} +function create_if_block_42(ctx) { + let div; + let current_block_type_index; + let if_block; + let div_transition; + let current; + const if_block_creators = [create_if_block_52, create_else_block_12]; + const if_blocks = []; + function select_block_type_1(ctx2, dirty) { + if ( + /*showTree*/ + ctx2[3] + ) + return 0; + return 1; + } + current_block_type_index = select_block_type_1(ctx, [-1, -1]); + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx); + return { + c() { + div = element("div"); + if_block.c(); + attr(div, "class", "tree-item-children nav-folder-children"); + }, + m(target, anchor) { + insert(target, div, anchor); + if_blocks[current_block_type_index].m(div, null); + current = true; + }, + p(ctx2, dirty) { + let previous_block_index = current_block_type_index; + current_block_type_index = select_block_type_1(ctx2, dirty); + if (current_block_type_index === previous_block_index) { + if_blocks[current_block_type_index].p(ctx2, dirty); + } else { + group_outros(); + transition_out(if_blocks[previous_block_index], 1, 1, () => { + if_blocks[previous_block_index] = null; + }); + check_outros(); + if_block = if_blocks[current_block_type_index]; + if (!if_block) { + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2); + if_block.c(); + } else { + if_block.p(ctx2, dirty); + } + transition_in(if_block, 1); + if_block.m(div, null); + } + }, + i(local) { + if (current) + return; + transition_in(if_block); + if (local) { + add_render_callback(() => { + if (!current) + return; + if (!div_transition) + div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, true); + div_transition.run(1); + }); + } + current = true; + }, + o(local) { + transition_out(if_block); + if (local) { + if (!div_transition) + div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, false); + div_transition.run(0); + } + current = false; + }, + d(detaching) { + if (detaching) { + detach(div); + } + if_blocks[current_block_type_index].d(); + if (detaching && div_transition) + div_transition.end(); + } + }; +} +function create_else_block_12(ctx) { + let each_1_anchor; + let current; + let each_value_1 = ensure_array_like( + /*status*/ + ctx[6].changed + ); + let each_blocks = []; + for (let i = 0; i < each_value_1.length; i += 1) { + each_blocks[i] = create_each_block_1(get_each_context_1(ctx, each_value_1, i)); + } + const out = (i) => transition_out(each_blocks[i], 1, 1, () => { + each_blocks[i] = null; + }); + return { + c() { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + each_1_anchor = empty(); + }, + m(target, anchor) { + for (let i = 0; i < each_blocks.length; i += 1) { + if (each_blocks[i]) { + each_blocks[i].m(target, anchor); + } + } + insert(target, each_1_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + if (dirty[0] & /*status, view, plugin*/ + 67) { + each_value_1 = ensure_array_like( + /*status*/ + ctx2[6].changed + ); + let i; + for (i = 0; i < each_value_1.length; i += 1) { + const child_ctx = get_each_context_1(ctx2, each_value_1, i); + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + transition_in(each_blocks[i], 1); + } else { + each_blocks[i] = create_each_block_1(child_ctx); + each_blocks[i].c(); + transition_in(each_blocks[i], 1); + each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor); + } + } + group_outros(); + for (i = each_value_1.length; i < each_blocks.length; i += 1) { + out(i); + } + check_outros(); + } + }, + i(local) { + if (current) + return; + for (let i = 0; i < each_value_1.length; i += 1) { + transition_in(each_blocks[i]); + } + current = true; + }, + o(local) { + each_blocks = each_blocks.filter(Boolean); + for (let i = 0; i < each_blocks.length; i += 1) { + transition_out(each_blocks[i]); + } + current = false; + }, + d(detaching) { + if (detaching) { + detach(each_1_anchor); + } + destroy_each(each_blocks, detaching); + } + }; +} +function create_if_block_52(ctx) { + let treecomponent; + let current; + treecomponent = new treeComponent_default({ + props: { + hierarchy: ( + /*changeHierarchy*/ + ctx[9] + ), + plugin: ( + /*plugin*/ + ctx[0] + ), + view: ( + /*view*/ + ctx[1] + ), + fileType: 1 /* changed */, + topLevel: true + } + }); + return { + c() { + create_component(treecomponent.$$.fragment); + }, + m(target, anchor) { + mount_component(treecomponent, target, anchor); + current = true; + }, + p(ctx2, dirty) { + const treecomponent_changes = {}; + if (dirty[0] & /*changeHierarchy*/ + 512) + treecomponent_changes.hierarchy = /*changeHierarchy*/ + ctx2[9]; + if (dirty[0] & /*plugin*/ + 1) + treecomponent_changes.plugin = /*plugin*/ + ctx2[0]; + if (dirty[0] & /*view*/ + 2) + treecomponent_changes.view = /*view*/ + ctx2[1]; + treecomponent.$set(treecomponent_changes); + }, + i(local) { + if (current) + return; + transition_in(treecomponent.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(treecomponent.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(treecomponent, detaching); + } + }; +} +function create_each_block_1(ctx) { + let filecomponent; + let current; + filecomponent = new fileComponent_default({ + props: { + change: ( + /*change*/ + ctx[40] + ), + view: ( + /*view*/ + ctx[1] + ), + manager: ( + /*plugin*/ + ctx[0].gitManager + ) + } + }); + filecomponent.$on("git-refresh", triggerRefresh2); + return { + c() { + create_component(filecomponent.$$.fragment); + }, + m(target, anchor) { + mount_component(filecomponent, target, anchor); + current = true; + }, + p(ctx2, dirty) { + const filecomponent_changes = {}; + if (dirty[0] & /*status*/ + 64) + filecomponent_changes.change = /*change*/ + ctx2[40]; + if (dirty[0] & /*view*/ + 2) + filecomponent_changes.view = /*view*/ + ctx2[1]; + if (dirty[0] & /*plugin*/ + 1) + filecomponent_changes.manager = /*plugin*/ + ctx2[0].gitManager; + filecomponent.$set(filecomponent_changes); + }, + i(local) { + if (current) + return; + transition_in(filecomponent.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(filecomponent.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(filecomponent, detaching); + } + }; +} +function create_if_block_14(ctx) { + let div3; + let div2; + let div0; + let t0; + let div1; + let t2; + let span; + let t3_value = ( + /*lastPulledFiles*/ + ctx[7].length + "" + ); + let t3; + let t4; + let current; + let mounted; + let dispose; + let if_block = ( + /*lastPulledFilesOpen*/ + ctx[14] && create_if_block_23(ctx) + ); + return { + c() { + div3 = element("div"); + div2 = element("div"); + div0 = element("div"); + div0.innerHTML = ``; + t0 = space(); + div1 = element("div"); + div1.textContent = "Recently Pulled Files"; + t2 = space(); + span = element("span"); + t3 = text(t3_value); + t4 = space(); + if (if_block) + if_block.c(); + attr(div0, "class", "tree-item-icon nav-folder-collapse-indicator collapse-icon"); + attr(div1, "class", "tree-item-inner nav-folder-title-content"); + attr(span, "class", "tree-item-flair"); + attr(div2, "class", "tree-item-self is-clickable nav-folder-title"); + attr(div3, "class", "pulled nav-folder"); + toggle_class(div3, "is-collapsed", !/*lastPulledFilesOpen*/ + ctx[14]); + }, + m(target, anchor) { + insert(target, div3, anchor); + append2(div3, div2); + append2(div2, div0); + append2(div2, t0); + append2(div2, div1); + append2(div2, t2); + append2(div2, span); + append2(span, t3); + append2(div3, t4); + if (if_block) + if_block.m(div3, null); + current = true; + if (!mounted) { + dispose = listen( + div2, + "click", + /*click_handler_4*/ + ctx[38] + ); + mounted = true; + } + }, + p(ctx2, dirty) { + if ((!current || dirty[0] & /*lastPulledFiles*/ + 128) && t3_value !== (t3_value = /*lastPulledFiles*/ + ctx2[7].length + "")) + set_data(t3, t3_value); + if ( + /*lastPulledFilesOpen*/ + ctx2[14] + ) { + if (if_block) { + if_block.p(ctx2, dirty); + if (dirty[0] & /*lastPulledFilesOpen*/ + 16384) { + transition_in(if_block, 1); + } + } else { + if_block = create_if_block_23(ctx2); + if_block.c(); + transition_in(if_block, 1); + if_block.m(div3, null); + } + } else if (if_block) { + group_outros(); + transition_out(if_block, 1, 1, () => { + if_block = null; + }); + check_outros(); + } + if (!current || dirty[0] & /*lastPulledFilesOpen*/ + 16384) { + toggle_class(div3, "is-collapsed", !/*lastPulledFilesOpen*/ + ctx2[14]); + } + }, + i(local) { + if (current) + return; + transition_in(if_block); + current = true; + }, + o(local) { + transition_out(if_block); + current = false; + }, + d(detaching) { + if (detaching) { + detach(div3); + } + if (if_block) + if_block.d(); + mounted = false; + dispose(); + } + }; +} +function create_if_block_23(ctx) { + let div; + let current_block_type_index; + let if_block; + let div_transition; + let current; + const if_block_creators = [create_if_block_32, create_else_block4]; + const if_blocks = []; + function select_block_type_2(ctx2, dirty) { + if ( + /*showTree*/ + ctx2[3] + ) + return 0; + return 1; + } + current_block_type_index = select_block_type_2(ctx, [-1, -1]); + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx); + return { + c() { + div = element("div"); + if_block.c(); + attr(div, "class", "tree-item-children nav-folder-children"); + }, + m(target, anchor) { + insert(target, div, anchor); + if_blocks[current_block_type_index].m(div, null); + current = true; + }, + p(ctx2, dirty) { + let previous_block_index = current_block_type_index; + current_block_type_index = select_block_type_2(ctx2, dirty); + if (current_block_type_index === previous_block_index) { + if_blocks[current_block_type_index].p(ctx2, dirty); + } else { + group_outros(); + transition_out(if_blocks[previous_block_index], 1, 1, () => { + if_blocks[previous_block_index] = null; + }); + check_outros(); + if_block = if_blocks[current_block_type_index]; + if (!if_block) { + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2); + if_block.c(); + } else { + if_block.p(ctx2, dirty); + } + transition_in(if_block, 1); + if_block.m(div, null); + } + }, + i(local) { + if (current) + return; + transition_in(if_block); + if (local) { + add_render_callback(() => { + if (!current) + return; + if (!div_transition) + div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, true); + div_transition.run(1); + }); + } + current = true; + }, + o(local) { + transition_out(if_block); + if (local) { + if (!div_transition) + div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, false); + div_transition.run(0); + } + current = false; + }, + d(detaching) { + if (detaching) { + detach(div); + } + if_blocks[current_block_type_index].d(); + if (detaching && div_transition) + div_transition.end(); + } + }; +} +function create_else_block4(ctx) { + let each_1_anchor; + let current; + let each_value = ensure_array_like( + /*lastPulledFiles*/ + ctx[7] + ); + let each_blocks = []; + for (let i = 0; i < each_value.length; i += 1) { + each_blocks[i] = create_each_block5(get_each_context5(ctx, each_value, i)); + } + const out = (i) => transition_out(each_blocks[i], 1, 1, () => { + each_blocks[i] = null; + }); + return { + c() { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + each_1_anchor = empty(); + }, + m(target, anchor) { + for (let i = 0; i < each_blocks.length; i += 1) { + if (each_blocks[i]) { + each_blocks[i].m(target, anchor); + } + } + insert(target, each_1_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + if (dirty[0] & /*lastPulledFiles, view*/ + 130) { + each_value = ensure_array_like( + /*lastPulledFiles*/ + ctx2[7] + ); + let i; + for (i = 0; i < each_value.length; i += 1) { + const child_ctx = get_each_context5(ctx2, each_value, i); + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + transition_in(each_blocks[i], 1); + } else { + each_blocks[i] = create_each_block5(child_ctx); + each_blocks[i].c(); + transition_in(each_blocks[i], 1); + each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor); + } + } + group_outros(); + for (i = each_value.length; i < each_blocks.length; i += 1) { + out(i); + } + check_outros(); + } + }, + i(local) { + if (current) + return; + for (let i = 0; i < each_value.length; i += 1) { + transition_in(each_blocks[i]); + } + current = true; + }, + o(local) { + each_blocks = each_blocks.filter(Boolean); + for (let i = 0; i < each_blocks.length; i += 1) { + transition_out(each_blocks[i]); + } + current = false; + }, + d(detaching) { + if (detaching) { + detach(each_1_anchor); + } + destroy_each(each_blocks, detaching); + } + }; +} +function create_if_block_32(ctx) { + let treecomponent; + let current; + treecomponent = new treeComponent_default({ + props: { + hierarchy: ( + /*lastPulledFilesHierarchy*/ + ctx[11] + ), + plugin: ( + /*plugin*/ + ctx[0] + ), + view: ( + /*view*/ + ctx[1] + ), + fileType: 2 /* pulled */, + topLevel: true + } + }); + return { + c() { + create_component(treecomponent.$$.fragment); + }, + m(target, anchor) { + mount_component(treecomponent, target, anchor); + current = true; + }, + p(ctx2, dirty) { + const treecomponent_changes = {}; + if (dirty[0] & /*lastPulledFilesHierarchy*/ + 2048) + treecomponent_changes.hierarchy = /*lastPulledFilesHierarchy*/ + ctx2[11]; + if (dirty[0] & /*plugin*/ + 1) + treecomponent_changes.plugin = /*plugin*/ + ctx2[0]; + if (dirty[0] & /*view*/ + 2) + treecomponent_changes.view = /*view*/ + ctx2[1]; + treecomponent.$set(treecomponent_changes); + }, + i(local) { + if (current) + return; + transition_in(treecomponent.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(treecomponent.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(treecomponent, detaching); + } + }; +} +function create_each_block5(ctx) { + let pulledfilecomponent; + let current; + pulledfilecomponent = new pulledFileComponent_default({ + props: { + change: ( + /*change*/ + ctx[40] + ), + view: ( + /*view*/ + ctx[1] + ) + } + }); + pulledfilecomponent.$on("git-refresh", triggerRefresh2); + return { + c() { + create_component(pulledfilecomponent.$$.fragment); + }, + m(target, anchor) { + mount_component(pulledfilecomponent, target, anchor); + current = true; + }, + p(ctx2, dirty) { + const pulledfilecomponent_changes = {}; + if (dirty[0] & /*lastPulledFiles*/ + 128) + pulledfilecomponent_changes.change = /*change*/ + ctx2[40]; + if (dirty[0] & /*view*/ + 2) + pulledfilecomponent_changes.view = /*view*/ + ctx2[1]; + pulledfilecomponent.$set(pulledfilecomponent_changes); + }, + i(local) { + if (current) + return; + transition_in(pulledfilecomponent.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(pulledfilecomponent.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(pulledfilecomponent, detaching); + } + }; +} +function create_fragment9(ctx) { + let main; + let div9; + let div8; + let div0; + let t0; + let div1; + let t1; + let div2; + let t2; + let div3; + let t3; + let div4; + let t4; + let div5; + let t5; + let div6; + let t6; + let div7; + let t7; + let div10; + let textarea; + let t8; + let t9; + let div11; + let current; + let mounted; + let dispose; + let if_block0 = ( + /*commitMessage*/ + ctx[2] && create_if_block_8(ctx) + ); + let if_block1 = ( + /*status*/ + ctx[6] && /*stagedHierarchy*/ + ctx[10] && /*changeHierarchy*/ + ctx[9] && create_if_block8(ctx) + ); + return { + c() { + main = element("main"); + div9 = element("div"); + div8 = element("div"); + div0 = element("div"); + t0 = space(); + div1 = element("div"); + t1 = space(); + div2 = element("div"); + t2 = space(); + div3 = element("div"); + t3 = space(); + div4 = element("div"); + t4 = space(); + div5 = element("div"); + t5 = space(); + div6 = element("div"); + t6 = space(); + div7 = element("div"); + t7 = space(); + div10 = element("div"); + textarea = element("textarea"); + t8 = space(); + if (if_block0) + if_block0.c(); + t9 = space(); + div11 = element("div"); + if (if_block1) + if_block1.c(); + attr(div0, "id", "backup-btn"); + attr(div0, "data-icon", "arrow-up-circle"); + attr(div0, "class", "clickable-icon nav-action-button"); + attr(div0, "aria-label", "Backup"); + attr(div1, "id", "commit-btn"); + attr(div1, "data-icon", "check"); + attr(div1, "class", "clickable-icon nav-action-button"); + attr(div1, "aria-label", "Commit"); + attr(div2, "id", "stage-all"); + attr(div2, "class", "clickable-icon nav-action-button"); + attr(div2, "data-icon", "plus-circle"); + attr(div2, "aria-label", "Stage all"); + attr(div3, "id", "unstage-all"); + attr(div3, "class", "clickable-icon nav-action-button"); + attr(div3, "data-icon", "minus-circle"); + attr(div3, "aria-label", "Unstage all"); + attr(div4, "id", "push"); + attr(div4, "class", "clickable-icon nav-action-button"); + attr(div4, "data-icon", "upload"); + attr(div4, "aria-label", "Push"); + attr(div5, "id", "pull"); + attr(div5, "class", "clickable-icon nav-action-button"); + attr(div5, "data-icon", "download"); + attr(div5, "aria-label", "Pull"); + attr(div6, "id", "layoutChange"); + attr(div6, "class", "clickable-icon nav-action-button"); + attr(div6, "aria-label", "Change Layout"); + attr(div7, "id", "refresh"); + attr(div7, "class", "clickable-icon nav-action-button"); + attr(div7, "data-icon", "refresh-cw"); + attr(div7, "aria-label", "Refresh"); + set_style(div7, "margin", "1px"); + toggle_class( + div7, + "loading", + /*loading*/ + ctx[5] + ); + attr(div8, "class", "nav-buttons-container"); + attr(div9, "class", "nav-header"); + attr( + textarea, + "rows", + /*rows*/ + ctx[15] + ); + attr(textarea, "class", "commit-msg-input svelte-48bivb"); + attr(textarea, "spellcheck", "true"); + attr(textarea, "placeholder", "Commit Message"); + attr(div10, "class", "git-commit-msg svelte-48bivb"); + attr(div11, "class", "nav-files-container"); + set_style(div11, "position", "relative"); + attr(main, "class", "svelte-48bivb"); + }, + m(target, anchor) { + insert(target, main, anchor); + append2(main, div9); + append2(div9, div8); + append2(div8, div0); + ctx[23](div0); + append2(div8, t0); + append2(div8, div1); + ctx[24](div1); + append2(div8, t1); + append2(div8, div2); + ctx[25](div2); + append2(div8, t2); + append2(div8, div3); + ctx[26](div3); + append2(div8, t3); + append2(div8, div4); + ctx[27](div4); + append2(div8, t4); + append2(div8, div5); + ctx[28](div5); + append2(div8, t5); + append2(div8, div6); + ctx[29](div6); + append2(div8, t6); + append2(div8, div7); + ctx[31](div7); + append2(main, t7); + append2(main, div10); + append2(div10, textarea); + set_input_value( + textarea, + /*commitMessage*/ + ctx[2] + ); + append2(div10, t8); + if (if_block0) + if_block0.m(div10, null); + append2(main, t9); + append2(main, div11); + if (if_block1) + if_block1.m(div11, null); + current = true; + if (!mounted) { + dispose = [ + listen( + div0, + "click", + /*backup*/ + ctx[17] + ), + listen( + div1, + "click", + /*commit*/ + ctx[16] + ), + listen( + div2, + "click", + /*stageAll*/ + ctx[18] + ), + listen( + div3, + "click", + /*unstageAll*/ + ctx[19] + ), + listen( + div4, + "click", + /*push*/ + ctx[20] + ), + listen( + div5, + "click", + /*pull*/ + ctx[21] + ), + listen( + div6, + "click", + /*click_handler*/ + ctx[30] + ), + listen(div7, "click", triggerRefresh2), + listen( + textarea, + "input", + /*textarea_input_handler*/ + ctx[32] + ) + ]; + mounted = true; + } + }, + p(ctx2, dirty) { + if (!current || dirty[0] & /*loading*/ + 32) { + toggle_class( + div7, + "loading", + /*loading*/ + ctx2[5] + ); + } + if (!current || dirty[0] & /*rows*/ + 32768) { + attr( + textarea, + "rows", + /*rows*/ + ctx2[15] + ); + } + if (dirty[0] & /*commitMessage*/ + 4) { + set_input_value( + textarea, + /*commitMessage*/ + ctx2[2] + ); + } + if ( + /*commitMessage*/ + ctx2[2] + ) { + if (if_block0) { + if_block0.p(ctx2, dirty); + } else { + if_block0 = create_if_block_8(ctx2); + if_block0.c(); + if_block0.m(div10, null); + } + } else if (if_block0) { + if_block0.d(1); + if_block0 = null; + } + if ( + /*status*/ + ctx2[6] && /*stagedHierarchy*/ + ctx2[10] && /*changeHierarchy*/ + ctx2[9] + ) { + if (if_block1) { + if_block1.p(ctx2, dirty); + if (dirty[0] & /*status, stagedHierarchy, changeHierarchy*/ + 1600) { + transition_in(if_block1, 1); + } + } else { + if_block1 = create_if_block8(ctx2); + if_block1.c(); + transition_in(if_block1, 1); + if_block1.m(div11, null); + } + } else if (if_block1) { + group_outros(); + transition_out(if_block1, 1, 1, () => { + if_block1 = null; + }); + check_outros(); + } + }, + i(local) { + if (current) + return; + transition_in(if_block1); + current = true; + }, + o(local) { + transition_out(if_block1); + current = false; + }, + d(detaching) { + if (detaching) { + detach(main); + } + ctx[23](null); + ctx[24](null); + ctx[25](null); + ctx[26](null); + ctx[27](null); + ctx[28](null); + ctx[29](null); + ctx[31](null); + if (if_block0) + if_block0.d(); + if (if_block1) + if_block1.d(); + mounted = false; + run_all(dispose); + } + }; +} +function triggerRefresh2() { + dispatchEvent(new CustomEvent("git-refresh")); +} +function instance9($$self, $$props, $$invalidate) { + let rows; + let { plugin } = $$props; + let { view } = $$props; + let loading; + let status2; + let lastPulledFiles = []; + let commitMessage = plugin.settings.commitMessage; + let buttons = []; + let changeHierarchy; + let stagedHierarchy; + let lastPulledFilesHierarchy; + let changesOpen = true; + let stagedOpen = true; + let lastPulledFilesOpen = true; + let showTree = plugin.settings.treeStructure; + let layoutBtn; + addEventListener("git-view-refresh", refresh); + plugin.app.workspace.onLayoutReady(() => { + window.setTimeout( + () => { + buttons.forEach((btn) => (0, import_obsidian28.setIcon)(btn, btn.getAttr("data-icon"), 16)); + (0, import_obsidian28.setIcon)(layoutBtn, showTree ? "list" : "folder", 16); + }, + 0 + ); + }); + onDestroy(() => { + removeEventListener("git-view-refresh", refresh); + }); + function commit2() { + return __awaiter(this, void 0, void 0, function* () { + $$invalidate(5, loading = true); + if (status2) { + if (yield plugin.hasTooBigFiles(status2.staged)) { + plugin.setState(0 /* idle */); + return false; + } + plugin.promiseQueue.addTask(() => plugin.gitManager.commit(commitMessage).then(() => { + if (commitMessage !== plugin.settings.commitMessage) { + $$invalidate(2, commitMessage = ""); + } + plugin.setUpAutoBackup(); + }).finally(triggerRefresh2)); + } + }); + } + function backup() { + return __awaiter(this, void 0, void 0, function* () { + $$invalidate(5, loading = true); + if (status2) { + plugin.promiseQueue.addTask(() => plugin.createBackup(false, false, commitMessage).then(() => { + if (commitMessage !== plugin.settings.commitMessage) { + $$invalidate(2, commitMessage = ""); + } + }).finally(triggerRefresh2)); + } + }); + } + function refresh() { + return __awaiter(this, void 0, void 0, function* () { + if (!plugin.gitReady) { + $$invalidate(6, status2 = void 0); + return; + } + $$invalidate(6, status2 = plugin.cachedStatus); + if (plugin.lastPulledFiles && plugin.lastPulledFiles != lastPulledFiles) { + $$invalidate(7, lastPulledFiles = plugin.lastPulledFiles); + $$invalidate(11, lastPulledFilesHierarchy = { + title: "", + path: "", + vaultPath: "", + children: plugin.gitManager.getTreeStructure(lastPulledFiles) + }); + } + if (status2) { + const sort = (a, b) => { + return a.vault_path.split("/").last().localeCompare(getDisplayPath(b.vault_path)); + }; + status2.changed.sort(sort); + status2.staged.sort(sort); + if (status2.changed.length + status2.staged.length > 500) { + $$invalidate(6, status2 = void 0); + if (!plugin.loading) { + plugin.displayError("Too many changes to display"); + } + } else { + $$invalidate(9, changeHierarchy = { + title: "", + path: "", + vaultPath: "", + children: plugin.gitManager.getTreeStructure(status2.changed) + }); + $$invalidate(10, stagedHierarchy = { + title: "", + path: "", + vaultPath: "", + children: plugin.gitManager.getTreeStructure(status2.staged) + }); + } + } else { + $$invalidate(9, changeHierarchy = void 0); + $$invalidate(10, stagedHierarchy = void 0); + } + $$invalidate(5, loading = plugin.loading); + }); + } + function stageAll() { + $$invalidate(5, loading = true); + plugin.promiseQueue.addTask(() => plugin.gitManager.stageAll({ status: status2 }).finally(triggerRefresh2)); + } + function unstageAll() { + $$invalidate(5, loading = true); + plugin.promiseQueue.addTask(() => plugin.gitManager.unstageAll({ status: status2 }).finally(triggerRefresh2)); + } + function push2() { + $$invalidate(5, loading = true); + plugin.promiseQueue.addTask(() => plugin.push().finally(triggerRefresh2)); + } + function pull2() { + $$invalidate(5, loading = true); + plugin.promiseQueue.addTask(() => plugin.pullChangesFromRemote().finally(triggerRefresh2)); + } + function discard() { + new DiscardModal(view.app, false, plugin.gitManager.getVaultPath("/")).myOpen().then((shouldDiscard) => { + if (shouldDiscard === true) { + plugin.promiseQueue.addTask(() => plugin.gitManager.discardAll({ status: plugin.cachedStatus }).finally(() => { + dispatchEvent(new CustomEvent("git-refresh")); + })); + } + }); + } + function div0_binding($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + buttons[5] = $$value; + $$invalidate(8, buttons); + }); + } + function div1_binding($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + buttons[0] = $$value; + $$invalidate(8, buttons); + }); + } + function div2_binding($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + buttons[1] = $$value; + $$invalidate(8, buttons); + }); + } + function div3_binding($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + buttons[2] = $$value; + $$invalidate(8, buttons); + }); + } + function div4_binding($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + buttons[3] = $$value; + $$invalidate(8, buttons); + }); + } + function div5_binding($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + buttons[4] = $$value; + $$invalidate(8, buttons); + }); + } + function div6_binding($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + layoutBtn = $$value; + $$invalidate(4, layoutBtn); + }); + } + const click_handler = () => { + $$invalidate(3, showTree = !showTree); + $$invalidate(0, plugin.settings.treeStructure = showTree, plugin); + plugin.saveSettings(); + }; + function div7_binding($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + buttons[6] = $$value; + $$invalidate(8, buttons); + }); + } + function textarea_input_handler() { + commitMessage = this.value; + $$invalidate(2, commitMessage); + } + const click_handler_1 = () => $$invalidate(2, commitMessage = ""); + function div2_binding_1($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + buttons[8] = $$value; + $$invalidate(8, buttons); + }); + } + const click_handler_2 = () => $$invalidate(13, stagedOpen = !stagedOpen); + function div11_binding($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + buttons[9] = $$value; + $$invalidate(8, buttons); + }); + } + const click_handler_3 = () => $$invalidate(12, changesOpen = !changesOpen); + const click_handler_4 = () => $$invalidate(14, lastPulledFilesOpen = !lastPulledFilesOpen); + $$self.$$set = ($$props2) => { + if ("plugin" in $$props2) + $$invalidate(0, plugin = $$props2.plugin); + if ("view" in $$props2) + $$invalidate(1, view = $$props2.view); + }; + $$self.$$.update = () => { + if ($$self.$$.dirty[0] & /*layoutBtn, showTree*/ + 24) { + $: { + if (layoutBtn) { + layoutBtn.empty(); + (0, import_obsidian28.setIcon)(layoutBtn, showTree ? "list" : "folder", 16); + } + } + } + if ($$self.$$.dirty[0] & /*commitMessage*/ + 4) { + $: + $$invalidate(15, rows = (commitMessage.match(/\n/g) || []).length + 1 || 1); + } + }; + return [ + plugin, + view, + commitMessage, + showTree, + layoutBtn, + loading, + status2, + lastPulledFiles, + buttons, + changeHierarchy, + stagedHierarchy, + lastPulledFilesHierarchy, + changesOpen, + stagedOpen, + lastPulledFilesOpen, + rows, + commit2, + backup, + stageAll, + unstageAll, + push2, + pull2, + discard, + div0_binding, + div1_binding, + div2_binding, + div3_binding, + div4_binding, + div5_binding, + div6_binding, + click_handler, + div7_binding, + textarea_input_handler, + click_handler_1, + div2_binding_1, + click_handler_2, + div11_binding, + click_handler_3, + click_handler_4 + ]; +} +var SourceControl = class extends SvelteComponent { + constructor(options) { + super(); + init2(this, options, instance9, create_fragment9, safe_not_equal, { plugin: 0, view: 1 }, add_css8, [-1, -1]); + } +}; +var sourceControl_default = SourceControl; + +// src/ui/sourceControl/sourceControl.ts +var GitView = class extends import_obsidian29.ItemView { + constructor(leaf, plugin) { + super(leaf); + this.plugin = plugin; + this.hoverPopover = null; + } + getViewType() { + return SOURCE_CONTROL_VIEW_CONFIG.type; + } + getDisplayText() { + return SOURCE_CONTROL_VIEW_CONFIG.name; + } + getIcon() { + return SOURCE_CONTROL_VIEW_CONFIG.icon; + } + onClose() { + return super.onClose(); + } + onOpen() { + this._view = new sourceControl_default({ + target: this.contentEl, + props: { + plugin: this.plugin, + view: this + } + }); + return super.onOpen(); + } +}; + +// src/ui/statusBar/branchStatusBar.ts +init_polyfill_buffer(); +var BranchStatusBar = class { + constructor(statusBarEl, plugin) { + this.statusBarEl = statusBarEl; + this.plugin = plugin; + this.statusBarEl.addClass("mod-clickable"); + this.statusBarEl.onClickEvent((e) => { + this.plugin.switchBranch(); + }); + } + async display() { + if (this.plugin.gitReady) { + const branchInfo = await this.plugin.gitManager.branchInfo(); + if (branchInfo.current != void 0) { + this.statusBarEl.setText(branchInfo.current); + } else { + this.statusBarEl.empty(); + } + } else { + this.statusBarEl.empty(); + } + } +}; + +// src/main.ts +var ObsidianGit = class extends import_obsidian30.Plugin { + constructor() { + super(...arguments); + this.gitReady = false; + this.promiseQueue = new PromiseQueue(); + this.conflictOutputFile = "conflict-files-obsidian-git.md"; + this.offlineMode = false; + this.loading = false; + this.lineAuthoringFeature = new LineAuthoringFeature(this); + } + setState(state) { + var _a2; + this.state = state; + (_a2 = this.statusBar) == null ? void 0 : _a2.display(); + } + async updateCachedStatus() { + this.cachedStatus = await this.gitManager.status(); + return this.cachedStatus; + } + async refresh() { + const gitView = this.app.workspace.getLeavesOfType( + SOURCE_CONTROL_VIEW_CONFIG.type + ); + const historyView = this.app.workspace.getLeavesOfType( + HISTORY_VIEW_CONFIG.type + ); + if (this.settings.changedFilesInStatusBar || gitView.length > 0 || historyView.length > 0) { + this.loading = true; + dispatchEvent(new CustomEvent("git-view-refresh")); + await this.updateCachedStatus(); + this.loading = false; + dispatchEvent(new CustomEvent("git-view-refresh")); + } + } + async refreshUpdatedHead() { + this.lineAuthoringFeature.refreshLineAuthorViews(); + } + async onload() { + console.log("loading " + this.manifest.name + " plugin"); + pluginRef.plugin = this; + this.localStorage = new LocalStorageSettings(this); + this.localStorage.migrate(); + await this.loadSettings(); + this.migrateSettings(); + this.settingsTab = new ObsidianGitSettingsTab(this.app, this); + this.addSettingTab(this.settingsTab); + if (!this.localStorage.getPluginDisabled()) { + this.loadPlugin(); + } + } + async loadPlugin() { + addEventListener("git-refresh", this.refresh.bind(this)); + addEventListener("git-head-update", this.refreshUpdatedHead.bind(this)); + this.registerView(SOURCE_CONTROL_VIEW_CONFIG.type, (leaf) => { + return new GitView(leaf, this); + }); + this.registerView(HISTORY_VIEW_CONFIG.type, (leaf) => { + return new HistoryView2(leaf, this); + }); + this.registerView(DIFF_VIEW_CONFIG.type, (leaf) => { + return new DiffView(leaf, this); + }); + this.lineAuthoringFeature.onLoadPlugin(); + this.app.workspace.registerHoverLinkSource( + SOURCE_CONTROL_VIEW_CONFIG.type, + { + display: "Git View", + defaultMod: true + } + ); + this.setRefreshDebouncer(); + this.addCommand({ + id: "edit-gitignore", + name: "Edit .gitignore", + callback: async () => { + const path2 = this.gitManager.getVaultPath(".gitignore"); + if (!await this.app.vault.adapter.exists(path2)) { + this.app.vault.adapter.write(path2, ""); + } + const content = await this.app.vault.adapter.read(path2); + const modal = new IgnoreModal(this.app, content); + const res = await modal.open(); + if (res !== void 0) { + await this.app.vault.adapter.write(path2, res); + this.refresh(); + } + } + }); + this.addCommand({ + id: "open-git-view", + name: "Open source control view", + callback: async () => { + const leafs = this.app.workspace.getLeavesOfType( + SOURCE_CONTROL_VIEW_CONFIG.type + ); + let leaf; + if (leafs.length === 0) { + leaf = this.app.workspace.getRightLeaf(false); + await leaf.setViewState({ + type: SOURCE_CONTROL_VIEW_CONFIG.type + }); + } else { + leaf = leafs.first(); + } + this.app.workspace.revealLeaf(leaf); + dispatchEvent(new CustomEvent("git-refresh")); + } + }); + this.addCommand({ + id: "open-history-view", + name: "Open history view", + callback: async () => { + const leafs = this.app.workspace.getLeavesOfType( + HISTORY_VIEW_CONFIG.type + ); + let leaf; + if (leafs.length === 0) { + leaf = this.app.workspace.getRightLeaf(false); + await leaf.setViewState({ + type: HISTORY_VIEW_CONFIG.type + }); + } else { + leaf = leafs.first(); + } + this.app.workspace.revealLeaf(leaf); + dispatchEvent(new CustomEvent("git-refresh")); + } + }); + this.addCommand({ + id: "open-diff-view", + name: "Open diff view", + checkCallback: (checking) => { + var _a2; + const file = this.app.workspace.getActiveFile(); + if (checking) { + return file !== null; + } else { + (_a2 = getNewLeaf()) == null ? void 0 : _a2.setViewState({ + type: DIFF_VIEW_CONFIG.type, + active: true, + state: { + staged: false, + file: this.gitManager.asRepositoryRelativePath( + file.path, + true + ) + } + }); + } + } + }); + this.addCommand({ + id: "view-file-on-github", + name: "Open file on GitHub", + editorCallback: (editor, { file }) => { + if (file) + return openLineInGitHub(editor, file, this.gitManager); + } + }); + this.addCommand({ + id: "view-history-on-github", + name: "Open file history on GitHub", + editorCallback: (_, { file }) => { + if (file) + return openHistoryInGitHub(file, this.gitManager); + } + }); + this.addCommand({ + id: "pull", + name: "Pull", + callback: () => this.promiseQueue.addTask(() => this.pullChangesFromRemote()) + }); + this.addCommand({ + id: "switch-to-remote-branch", + name: "Switch to remote branch", + callback: () => this.promiseQueue.addTask(() => this.switchRemoteBranch()) + }); + this.addCommand({ + id: "add-to-gitignore", + name: "Add file to gitignore", + checkCallback: (checking) => { + const file = app.workspace.getActiveFile(); + if (checking) { + return file !== null; + } else { + app.vault.adapter.append( + this.gitManager.getVaultPath(".gitignore"), + "\n" + this.gitManager.asRepositoryRelativePath( + file.path, + true + ) + ).then(() => { + this.refresh(); + }); + } + } + }); + this.addCommand({ + id: "push", + name: "Create backup", + callback: () => this.promiseQueue.addTask(() => this.createBackup(false)) + }); + this.addCommand({ + id: "backup-and-close", + name: "Create backup and close", + callback: () => this.promiseQueue.addTask(async () => { + await this.createBackup(false); + window.close(); + }) + }); + this.addCommand({ + id: "commit-push-specified-message", + name: "Create backup with specific message", + callback: () => this.promiseQueue.addTask(() => this.createBackup(false, true)) + }); + this.addCommand({ + id: "commit", + name: "Commit all changes", + callback: () => this.promiseQueue.addTask( + () => this.commit({ fromAutoBackup: false }) + ) + }); + this.addCommand({ + id: "commit-specified-message", + name: "Commit all changes with specific message", + callback: () => this.promiseQueue.addTask( + () => this.commit({ + fromAutoBackup: false, + requestCustomMessage: true + }) + ) + }); + this.addCommand({ + id: "commit-staged", + name: "Commit staged", + callback: () => this.promiseQueue.addTask( + () => this.commit({ + fromAutoBackup: false, + requestCustomMessage: false, + onlyStaged: true + }) + ) + }); + this.addCommand({ + id: "commit-staged-specified-message", + name: "Commit staged with specific message", + callback: () => this.promiseQueue.addTask( + () => this.commit({ + fromAutoBackup: false, + requestCustomMessage: true, + onlyStaged: true + }) + ) + }); + this.addCommand({ + id: "push2", + name: "Push", + callback: () => this.promiseQueue.addTask(() => this.push()) + }); + this.addCommand({ + id: "stage-current-file", + name: "Stage current file", + checkCallback: (checking) => { + const file = this.app.workspace.getActiveFile(); + if (checking) { + return file !== null; + } else { + this.promiseQueue.addTask(() => this.stageFile(file)); + } + } + }); + this.addCommand({ + id: "unstage-current-file", + name: "Unstage current file", + checkCallback: (checking) => { + const file = this.app.workspace.getActiveFile(); + if (checking) { + return file !== null; + } else { + this.promiseQueue.addTask(() => this.unstageFile(file)); + } + } + }); + this.addCommand({ + id: "edit-remotes", + name: "Edit remotes", + callback: async () => this.editRemotes() + }); + this.addCommand({ + id: "remove-remote", + name: "Remove remote", + callback: async () => this.removeRemote() + }); + this.addCommand({ + id: "delete-repo", + name: "CAUTION: Delete repository", + callback: async () => { + const repoExists = await this.app.vault.adapter.exists( + `${this.settings.basePath}/.git` + ); + if (repoExists) { + const modal = new GeneralModal({ + options: ["NO", "YES"], + placeholder: "Do you really want to delete the repository (.git directory)? This action cannot be undone.", + onlySelection: true + }); + const shouldDelete = await modal.open() === "YES"; + if (shouldDelete) { + await this.app.vault.adapter.rmdir( + `${this.settings.basePath}/.git`, + true + ); + new import_obsidian30.Notice( + "Successfully deleted repository. Reloading plugin..." + ); + this.unloadPlugin(); + this.init(); + } + } else { + new import_obsidian30.Notice("No repository found"); + } + } + }); + this.addCommand({ + id: "init-repo", + name: "Initialize a new repo", + callback: async () => this.createNewRepo() + }); + this.addCommand({ + id: "clone-repo", + name: "Clone an existing remote repo", + callback: async () => this.cloneNewRepo() + }); + this.addCommand({ + id: "list-changed-files", + name: "List changed files", + callback: async () => { + if (!await this.isAllInitialized()) + return; + const status2 = await this.gitManager.status(); + this.setState(0 /* idle */); + if (status2.changed.length + status2.staged.length > 500) { + this.displayError("Too many changes to display"); + return; + } + new ChangedFilesModal(this, status2.changed).open(); + } + }); + this.addCommand({ + id: "switch-branch", + name: "Switch branch", + callback: () => { + this.switchBranch(); + } + }); + this.addCommand({ + id: "create-branch", + name: "Create new branch", + callback: () => { + this.createBranch(); + } + }); + this.addCommand({ + id: "delete-branch", + name: "Delete branch", + callback: () => { + this.deleteBranch(); + } + }); + this.addCommand({ + id: "discard-all", + name: "CAUTION: Discard all changes", + callback: async () => { + if (!await this.isAllInitialized()) + return false; + const modal = new GeneralModal({ + options: ["NO", "YES"], + placeholder: "Do you want to discard all changes to tracked files? This action cannot be undone.", + onlySelection: true + }); + const shouldDiscardAll = await modal.open() === "YES"; + if (shouldDiscardAll) { + this.promiseQueue.addTask(() => this.discardAll()); + } + } + }); + this.addCommand({ + id: "toggle-line-author-info", + name: "Toggle line author information", + callback: () => { + var _a2; + return (_a2 = this.settingsTab) == null ? void 0 : _a2.configureLineAuthorShowStatus( + !this.settings.lineAuthor.show + ); + } + }); + this.registerEvent( + this.app.workspace.on("file-menu", (menu, file, source) => { + this.handleFileMenu(menu, file, source); + }) + ); + if (this.settings.showStatusBar) { + const statusBarEl = this.addStatusBarItem(); + this.statusBar = new StatusBar(statusBarEl, this); + this.registerInterval( + window.setInterval(() => { + var _a2; + return (_a2 = this.statusBar) == null ? void 0 : _a2.display(); + }, 1e3) + ); + } + if (import_obsidian30.Platform.isDesktop && this.settings.showBranchStatusBar) { + const branchStatusBarEl = this.addStatusBarItem(); + this.branchBar = new BranchStatusBar(branchStatusBarEl, this); + this.registerInterval( + window.setInterval(() => { + var _a2; + return (_a2 = this.branchBar) == null ? void 0 : _a2.display(); + }, 6e4) + ); + } + this.app.workspace.onLayoutReady(() => this.init()); + } + setRefreshDebouncer() { + var _a2; + (_a2 = this.debRefresh) == null ? void 0 : _a2.cancel(); + this.debRefresh = (0, import_obsidian30.debounce)( + () => { + if (this.settings.refreshSourceControl) { + this.refresh(); + } + }, + this.settings.refreshSourceControlTimer, + true + ); + } + async showNotices() { + const length = 1e4; + if (this.manifest.id === "obsidian-git" && import_obsidian30.Platform.isDesktopApp && !this.settings.showedMobileNotice) { + new import_obsidian30.Notice( + "Obsidian Git is now available on mobile! Please read the plugin's README for more information.", + length + ); + this.settings.showedMobileNotice = true; + await this.saveSettings(); + } + if (this.manifest.id === "obsidian-git-isomorphic") { + new import_obsidian30.Notice( + "Obsidian Git Mobile is now deprecated. Please uninstall it and install Obsidian Git instead.", + length + ); + } + } + handleFileMenu(menu, file, source) { + if (!this.settings.showFileMenu) + return; + if (source !== "file-explorer-context-menu") { + return; + } + if (!file) { + return; + } + if (!this.gitReady) + return; + menu.addItem((item) => { + item.setTitle(`Git: Stage`).setIcon("plus-circle").setSection("action").onClick((_) => { + this.promiseQueue.addTask(async () => { + if (file instanceof import_obsidian30.TFile) { + await this.gitManager.stage(file.path, true); + } else { + await this.gitManager.stageAll({ + dir: this.gitManager.asRepositoryRelativePath( + file.path, + true + ) + }); + } + this.displayMessage(`Staged ${file.path}`); + }); + }); + }); + menu.addItem((item) => { + item.setTitle(`Git: Unstage`).setIcon("minus-circle").setSection("action").onClick((_) => { + this.promiseQueue.addTask(async () => { + if (file instanceof import_obsidian30.TFile) { + await this.gitManager.unstage(file.path, true); + } else { + await this.gitManager.unstageAll({ + dir: this.gitManager.asRepositoryRelativePath( + file.path, + true + ) + }); + } + this.displayMessage(`Unstaged ${file.path}`); + }); + }); + }); + } + async migrateSettings() { + if (this.settings.mergeOnPull != void 0) { + this.settings.syncMethod = this.settings.mergeOnPull ? "merge" : "rebase"; + this.settings.mergeOnPull = void 0; + await this.saveSettings(); + } + if (this.settings.autoCommitMessage === void 0) { + this.settings.autoCommitMessage = this.settings.commitMessage; + await this.saveSettings(); + } + if (this.settings.gitPath != void 0) { + this.localStorage.setGitPath(this.settings.gitPath); + this.settings.gitPath = void 0; + await this.saveSettings(); + } + if (this.settings.username != void 0) { + this.localStorage.setPassword(this.settings.username); + this.settings.username = void 0; + await this.saveSettings(); + } + } + unloadPlugin() { + this.gitReady = false; + dispatchEvent(new CustomEvent("git-refresh")); + this.lineAuthoringFeature.deactivateFeature(); + this.clearAutoPull(); + this.clearAutoPush(); + this.clearAutoBackup(); + removeEventListener("git-refresh", this.refresh.bind(this)); + removeEventListener( + "git-head-update", + this.refreshUpdatedHead.bind(this) + ); + this.app.metadataCache.offref(this.modifyEvent); + this.app.metadataCache.offref(this.deleteEvent); + this.app.metadataCache.offref(this.createEvent); + this.app.metadataCache.offref(this.renameEvent); + this.debRefresh.cancel(); + } + async onunload() { + this.app.workspace.unregisterHoverLinkSource( + SOURCE_CONTROL_VIEW_CONFIG.type + ); + this.unloadPlugin(); + console.log("unloading " + this.manifest.name + " plugin"); + } + async loadSettings() { + let data = await this.loadData(); + if (data == void 0) { + data = { showedMobileNotice: true }; + } + this.settings = mergeSettingsByPriority(DEFAULT_SETTINGS, data); + } + async saveSettings() { + var _a2; + (_a2 = this.settingsTab) == null ? void 0 : _a2.beforeSaveSettings(); + await this.saveData(this.settings); + } + saveLastAuto(date, mode) { + if (mode === "backup") { + this.localStorage.setLastAutoBackup(date.toString()); + } else if (mode === "pull") { + this.localStorage.setLastAutoPull(date.toString()); + } else if (mode === "push") { + this.localStorage.setLastAutoPush(date.toString()); + } + } + loadLastAuto() { + var _a2, _b, _c; + return { + backup: new Date((_a2 = this.localStorage.getLastAutoBackup()) != null ? _a2 : ""), + pull: new Date((_b = this.localStorage.getLastAutoPull()) != null ? _b : ""), + push: new Date((_c = this.localStorage.getLastAutoPush()) != null ? _c : "") + }; + } + get useSimpleGit() { + return import_obsidian30.Platform.isDesktopApp; + } + async init() { + var _a2; + this.showNotices(); + try { + if (this.useSimpleGit) { + this.gitManager = new SimpleGit(this); + await this.gitManager.setGitInstance(); + } else { + this.gitManager = new IsomorphicGit(this); + } + const result = await this.gitManager.checkRequirements(); + switch (result) { + case "missing-git": + this.displayError("Cannot run git command"); + break; + case "missing-repo": + new import_obsidian30.Notice( + "Can't find a valid git repository. Please create one via the given command or clone an existing repo.", + 1e4 + ); + break; + case "valid": + this.gitReady = true; + this.setState(0 /* idle */); + this.modifyEvent = this.app.vault.on("modify", () => { + this.debRefresh(); + }); + this.deleteEvent = this.app.vault.on("delete", () => { + this.debRefresh(); + }); + this.createEvent = this.app.vault.on("create", () => { + this.debRefresh(); + }); + this.renameEvent = this.app.vault.on("rename", () => { + this.debRefresh(); + }); + this.registerEvent(this.modifyEvent); + this.registerEvent(this.deleteEvent); + this.registerEvent(this.createEvent); + this.registerEvent(this.renameEvent); + (_a2 = this.branchBar) == null ? void 0 : _a2.display(); + this.lineAuthoringFeature.conditionallyActivateBySettings(); + dispatchEvent(new CustomEvent("git-refresh")); + if (this.settings.autoPullOnBoot) { + this.promiseQueue.addTask( + () => this.pullChangesFromRemote() + ); + } + this.setUpAutos(); + break; + default: + console.log( + "Something weird happened. The 'checkRequirements' result is " + result + ); + } + } catch (error) { + this.displayError(error); + console.error(error); + } + } + async createNewRepo() { + await this.gitManager.init(); + new import_obsidian30.Notice("Initialized new repo"); + await this.init(); + } + async cloneNewRepo() { + const modal = new GeneralModal({ placeholder: "Enter remote URL" }); + const url = await modal.open(); + if (url) { + const confirmOption = "Vault Root"; + let dir = await new GeneralModal({ + options: this.gitManager instanceof IsomorphicGit ? [confirmOption] : [], + placeholder: "Enter directory for clone. It needs to be empty or not existent.", + allowEmpty: this.gitManager instanceof IsomorphicGit + }).open(); + if (dir !== void 0) { + if (dir === confirmOption) { + dir = "."; + } + dir = (0, import_obsidian30.normalizePath)(dir); + if (dir === "/") { + dir = "."; + } + if (dir === ".") { + const modal2 = new GeneralModal({ + options: ["NO", "YES"], + placeholder: `Does your remote repo contain a ${app.vault.configDir} directory at the root?`, + onlySelection: true + }); + const containsConflictDir = await modal2.open(); + if (containsConflictDir === void 0) { + new import_obsidian30.Notice("Aborted clone"); + return; + } else if (containsConflictDir === "YES") { + const confirmOption2 = "DELETE ALL YOUR LOCAL CONFIG AND PLUGINS"; + const modal3 = new GeneralModal({ + options: ["Abort clone", confirmOption2], + placeholder: `To avoid conflicts, the local ${app.vault.configDir} directory needs to be deleted.`, + onlySelection: true + }); + const shouldDelete = await modal3.open() === confirmOption2; + if (shouldDelete) { + await this.app.vault.adapter.rmdir( + app.vault.configDir, + true + ); + } else { + new import_obsidian30.Notice("Aborted clone"); + return; + } + } + } + const depth = await new GeneralModal({ + placeholder: "Specify depth of clone. Leave empty for full clone.", + allowEmpty: true + }).open(); + let depthInt = void 0; + if (depth !== "") { + depthInt = parseInt(depth); + if (isNaN(depthInt)) { + new import_obsidian30.Notice("Invalid depth. Aborting clone."); + return; + } + } + new import_obsidian30.Notice(`Cloning new repo into "${dir}"`); + const oldBase = this.settings.basePath; + const customDir = dir && dir !== "."; + if (customDir) { + this.settings.basePath = dir; + } + try { + await this.gitManager.clone(url, dir, depthInt); + } catch (error) { + this.settings.basePath = oldBase; + this.saveSettings(); + throw error; + } + new import_obsidian30.Notice("Cloned new repo."); + new import_obsidian30.Notice("Please restart Obsidian"); + if (customDir) { + this.saveSettings(); + } + } + } + } + /** + * Retries to call `this.init()` if necessary, otherwise returns directly + * @returns true if `this.gitManager` is ready to be used, false if not. + */ + async isAllInitialized() { + if (!this.gitReady) { + await this.init(); + } + return this.gitReady; + } + ///Used for command + async pullChangesFromRemote() { + if (!await this.isAllInitialized()) + return; + const filesUpdated = await this.pull(); + this.setUpAutoBackup(); + if (!filesUpdated) { + this.displayMessage("Everything is up-to-date"); + } + if (this.gitManager instanceof SimpleGit) { + const status2 = await this.gitManager.status(); + if (status2.conflicted.length > 0) { + this.displayError( + `You have conflicts in ${status2.conflicted.length} ${status2.conflicted.length == 1 ? "file" : "files"}` + ); + this.handleConflict(status2.conflicted); + } + } + dispatchEvent(new CustomEvent("git-refresh")); + this.setState(0 /* idle */); + } + async createBackup(fromAutoBackup, requestCustomMessage = false, commitMessage) { + if (!await this.isAllInitialized()) + return; + if (this.settings.syncMethod == "reset" && this.settings.pullBeforePush) { + await this.pull(); + } + if (!await this.commit({ + fromAutoBackup, + requestCustomMessage, + commitMessage + })) + return; + if (!this.settings.disablePush) { + if (await this.gitManager.canPush()) { + if (this.settings.syncMethod != "reset" && this.settings.pullBeforePush) { + await this.pull(); + } + await this.push(); + } else { + this.displayMessage("No changes to push"); + } + } + this.setState(0 /* idle */); + } + // Returns true if commit was successfully + async commit({ + fromAutoBackup, + requestCustomMessage = false, + onlyStaged = false, + commitMessage + }) { + if (!await this.isAllInitialized()) + return false; + let hadConflict = this.localStorage.getConflict() === "true"; + let changedFiles; + let status2; + let unstagedFiles; + if (this.gitManager instanceof SimpleGit) { + this.mayDeleteConflictFile(); + status2 = await this.updateCachedStatus(); + if (status2.conflicted.length == 0) { + this.localStorage.setConflict("false"); + hadConflict = false; + } + if (fromAutoBackup && status2.conflicted.length > 0) { + this.displayError( + `Did not commit, because you have conflicts in ${status2.conflicted.length} ${status2.conflicted.length == 1 ? "file" : "files"}. Please resolve them and commit per command.` + ); + this.handleConflict(status2.conflicted); + return false; + } + changedFiles = [...status2.changed, ...status2.staged]; + } else if (fromAutoBackup && hadConflict) { + this.setState(6 /* conflicted */); + this.displayError( + `Did not commit, because you have conflicts. Please resolve them and commit per command.` + ); + return false; + } else if (hadConflict) { + await this.mayDeleteConflictFile(); + status2 = await this.updateCachedStatus(); + changedFiles = [...status2.changed, ...status2.staged]; + } else { + if (onlyStaged) { + changedFiles = await this.gitManager.getStagedFiles(); + } else { + unstagedFiles = await this.gitManager.getUnstagedFiles(); + changedFiles = unstagedFiles.map(({ filepath }) => ({ + vault_path: this.gitManager.getVaultPath(filepath) + })); + } + } + if (await this.hasTooBigFiles(changedFiles)) { + this.setState(0 /* idle */); + return false; + } + if (changedFiles.length !== 0 || hadConflict) { + let cmtMessage = commitMessage != null ? commitMessage : commitMessage = fromAutoBackup ? this.settings.autoCommitMessage : this.settings.commitMessage; + if (fromAutoBackup && this.settings.customMessageOnAutoBackup || requestCustomMessage) { + if (!this.settings.disablePopups && fromAutoBackup) { + new import_obsidian30.Notice( + "Auto backup: Please enter a custom commit message. Leave empty to abort" + ); + } + const tempMessage = await new CustomMessageModal( + this, + true + ).open(); + if (tempMessage != void 0 && tempMessage != "" && tempMessage != "...") { + cmtMessage = tempMessage; + } else { + this.setState(0 /* idle */); + return false; + } + } + let committedFiles; + if (onlyStaged) { + committedFiles = await this.gitManager.commit(cmtMessage); + } else { + committedFiles = await this.gitManager.commitAll({ + message: cmtMessage, + status: status2, + unstagedFiles + }); + } + if (this.gitManager instanceof SimpleGit) { + if ((await this.updateCachedStatus()).conflicted.length == 0) { + this.localStorage.setConflict("false"); + } + } + let roughly = false; + if (committedFiles === void 0) { + roughly = true; + committedFiles = changedFiles.length; + } + this.setUpAutoBackup(); + this.displayMessage( + `Committed${roughly ? " approx." : ""} ${committedFiles} ${committedFiles == 1 ? "file" : "files"}` + ); + } else { + this.displayMessage("No changes to commit"); + } + dispatchEvent(new CustomEvent("git-refresh")); + this.setState(0 /* idle */); + return true; + } + async hasTooBigFiles(files) { + const branchInfo = await this.gitManager.branchInfo(); + const remote = branchInfo.tracking ? splitRemoteBranch(branchInfo.tracking)[0] : null; + if (remote) { + const remoteUrl = await this.gitManager.getRemoteUrl(remote); + if (remoteUrl == null ? void 0 : remoteUrl.includes("github.com")) { + const tooBigFiles = files.filter((f) => { + const file = this.app.vault.getAbstractFileByPath( + f.vault_path + ); + if (file instanceof import_obsidian30.TFile) { + return file.stat.size >= 1e8; + } + return false; + }); + if (tooBigFiles.length > 0) { + this.displayError( + `Did not commit, because following files are too big: ${tooBigFiles.map( + (e) => e.vault_path + )}. Please remove them.` + ); + return true; + } + } + } + return false; + } + async push() { + if (!await this.isAllInitialized()) + return false; + if (!await this.remotesAreSet()) { + return false; + } + const hadConflict = this.localStorage.getConflict() === "true"; + if (this.gitManager instanceof SimpleGit) + await this.mayDeleteConflictFile(); + let status2; + if (this.gitManager instanceof SimpleGit && (status2 = await this.updateCachedStatus()).conflicted.length > 0) { + this.displayError( + `Cannot push. You have conflicts in ${status2.conflicted.length} ${status2.conflicted.length == 1 ? "file" : "files"}` + ); + this.handleConflict(status2.conflicted); + return false; + } else if (this.gitManager instanceof IsomorphicGit && hadConflict) { + this.displayError(`Cannot push. You have conflicts`); + this.setState(6 /* conflicted */); + return false; + } + { + console.log("Pushing...."); + const pushedFiles = await this.gitManager.push(); + console.log("Pushed!", pushedFiles); + if (pushedFiles > 0) { + this.displayMessage( + `Pushed ${pushedFiles} ${pushedFiles == 1 ? "file" : "files"} to remote` + ); + } else { + this.displayMessage(`No changes to push`); + } + this.offlineMode = false; + this.setState(0 /* idle */); + return true; + } + } + /// Used for internals + /// Returns whether the pull added a commit or not. + async pull() { + if (!await this.remotesAreSet()) { + return false; + } + const pulledFiles = await this.gitManager.pull() || []; + this.offlineMode = false; + if (pulledFiles.length > 0) { + this.displayMessage( + `Pulled ${pulledFiles.length} ${pulledFiles.length == 1 ? "file" : "files"} from remote` + ); + this.lastPulledFiles = pulledFiles; + } + return pulledFiles.length != 0; + } + async mayDeleteConflictFile() { + const file = this.app.vault.getAbstractFileByPath( + this.conflictOutputFile + ); + if (file) { + this.app.workspace.iterateAllLeaves((leaf) => { + if (leaf.view instanceof import_obsidian30.MarkdownView && leaf.view.file.path == file.path) { + leaf.detach(); + } + }); + await this.app.vault.delete(file); + } + } + async stageFile(file) { + if (!await this.isAllInitialized()) + return false; + await this.gitManager.stage(file.path, true); + this.displayMessage(`Staged ${file.path}`); + dispatchEvent(new CustomEvent("git-refresh")); + this.setState(0 /* idle */); + return true; + } + async unstageFile(file) { + if (!await this.isAllInitialized()) + return false; + await this.gitManager.unstage(file.path, true); + this.displayMessage(`Unstaged ${file.path}`); + dispatchEvent(new CustomEvent("git-refresh")); + this.setState(0 /* idle */); + return true; + } + async switchBranch() { + var _a2; + if (!await this.isAllInitialized()) + return; + const branchInfo = await this.gitManager.branchInfo(); + const selectedBranch = await new BranchModal( + branchInfo.branches + ).open(); + if (selectedBranch != void 0) { + await this.gitManager.checkout(selectedBranch); + this.displayMessage(`Switched to ${selectedBranch}`); + (_a2 = this.branchBar) == null ? void 0 : _a2.display(); + return selectedBranch; + } + } + async switchRemoteBranch() { + var _a2; + if (!await this.isAllInitialized()) + return; + const selectedBranch = await this.selectRemoteBranch() || ""; + const [remote, branch2] = splitRemoteBranch(selectedBranch); + if (branch2 != void 0 && remote != void 0) { + await this.gitManager.checkout(branch2, remote); + this.displayMessage(`Switched to ${selectedBranch}`); + (_a2 = this.branchBar) == null ? void 0 : _a2.display(); + return selectedBranch; + } + } + async createBranch() { + var _a2; + if (!await this.isAllInitialized()) + return; + const newBranch = await new GeneralModal({ + placeholder: "Create new branch" + }).open(); + if (newBranch != void 0) { + await this.gitManager.createBranch(newBranch); + this.displayMessage(`Created new branch ${newBranch}`); + (_a2 = this.branchBar) == null ? void 0 : _a2.display(); + return newBranch; + } + } + async deleteBranch() { + var _a2; + if (!await this.isAllInitialized()) + return; + const branchInfo = await this.gitManager.branchInfo(); + if (branchInfo.current) + branchInfo.branches.remove(branchInfo.current); + const branch2 = await new GeneralModal({ + options: branchInfo.branches, + placeholder: "Delete branch", + onlySelection: true + }).open(); + if (branch2 != void 0) { + let force = false; + const merged = await this.gitManager.branchIsMerged(branch2); + if (!merged) { + const forceAnswer = await new GeneralModal({ + options: ["YES", "NO"], + placeholder: "This branch isn't merged into HEAD. Force delete?", + onlySelection: true + }).open(); + if (forceAnswer !== "YES") { + return; + } + force = forceAnswer === "YES"; + } + await this.gitManager.deleteBranch(branch2, force); + this.displayMessage(`Deleted branch ${branch2}`); + (_a2 = this.branchBar) == null ? void 0 : _a2.display(); + return branch2; + } + } + async remotesAreSet() { + if (!(await this.gitManager.branchInfo()).tracking) { + new import_obsidian30.Notice("No upstream branch is set. Please select one."); + const remoteBranch = await this.selectRemoteBranch(); + if (remoteBranch == void 0) { + this.displayError("Aborted. No upstream-branch is set!", 1e4); + this.setState(0 /* idle */); + return false; + } else { + await this.gitManager.updateUpstreamBranch(remoteBranch); + return true; + } + } + return true; + } + async setUpAutoBackup() { + if (this.settings.setLastSaveToLastCommit) { + this.clearAutoBackup(); + const lastCommitDate = await this.gitManager.getLastCommitTime(); + if (lastCommitDate) { + this.localStorage.setLastAutoBackup(lastCommitDate.toString()); + } + } + if (!this.timeoutIDBackup && !this.onFileModifyEventRef) { + const lastAutos = await this.loadLastAuto(); + if (this.settings.autoSaveInterval > 0) { + const now2 = /* @__PURE__ */ new Date(); + const diff2 = this.settings.autoSaveInterval - Math.round( + (now2.getTime() - lastAutos.backup.getTime()) / 1e3 / 60 + ); + this.startAutoBackup(diff2 <= 0 ? 0 : diff2); + } + } + } + async setUpAutos() { + this.setUpAutoBackup(); + const lastAutos = await this.loadLastAuto(); + if (this.settings.differentIntervalCommitAndPush && this.settings.autoPushInterval > 0) { + const now2 = /* @__PURE__ */ new Date(); + const diff2 = this.settings.autoPushInterval - Math.round( + (now2.getTime() - lastAutos.push.getTime()) / 1e3 / 60 + ); + this.startAutoPush(diff2 <= 0 ? 0 : diff2); + } + if (this.settings.autoPullInterval > 0) { + const now2 = /* @__PURE__ */ new Date(); + const diff2 = this.settings.autoPullInterval - Math.round( + (now2.getTime() - lastAutos.pull.getTime()) / 1e3 / 60 + ); + this.startAutoPull(diff2 <= 0 ? 0 : diff2); + } + } + async discardAll() { + await this.gitManager.discardAll({ + status: this.cachedStatus + }); + new import_obsidian30.Notice( + "All local changes have been discarded. New files remain untouched." + ); + } + clearAutos() { + this.clearAutoBackup(); + this.clearAutoPush(); + this.clearAutoPull(); + } + startAutoBackup(minutes) { + let time = (minutes != null ? minutes : this.settings.autoSaveInterval) * 6e4; + if (this.settings.autoBackupAfterFileChange) { + if (minutes === 0) { + this.doAutoBackup(); + } else { + this.onFileModifyEventRef = this.app.vault.on( + "modify", + () => this.autoBackupDebouncer() + ); + this.autoBackupDebouncer = (0, import_obsidian30.debounce)( + () => this.doAutoBackup(), + time, + true + ); + } + } else { + if (time > 2147483647) + time = 2147483647; + this.timeoutIDBackup = window.setTimeout( + () => this.doAutoBackup(), + time + ); + } + } + // This is used for both auto backup and commit + doAutoBackup() { + this.promiseQueue.addTask(() => { + if (this.settings.differentIntervalCommitAndPush) { + return this.commit({ fromAutoBackup: true }); + } else { + return this.createBackup(true); + } + }); + this.saveLastAuto(/* @__PURE__ */ new Date(), "backup"); + this.saveSettings(); + this.startAutoBackup(); + } + startAutoPull(minutes) { + let time = (minutes != null ? minutes : this.settings.autoPullInterval) * 6e4; + if (time > 2147483647) + time = 2147483647; + this.timeoutIDPull = window.setTimeout(() => { + this.promiseQueue.addTask(() => this.pullChangesFromRemote()); + this.saveLastAuto(/* @__PURE__ */ new Date(), "pull"); + this.saveSettings(); + this.startAutoPull(); + }, time); + } + startAutoPush(minutes) { + let time = (minutes != null ? minutes : this.settings.autoPushInterval) * 6e4; + if (time > 2147483647) + time = 2147483647; + this.timeoutIDPush = window.setTimeout(() => { + this.promiseQueue.addTask(() => this.push()); + this.saveLastAuto(/* @__PURE__ */ new Date(), "push"); + this.saveSettings(); + this.startAutoPush(); + }, time); + } + clearAutoBackup() { + var _a2; + let wasActive = false; + if (this.timeoutIDBackup) { + window.clearTimeout(this.timeoutIDBackup); + this.timeoutIDBackup = void 0; + wasActive = true; + } + if (this.onFileModifyEventRef) { + (_a2 = this.autoBackupDebouncer) == null ? void 0 : _a2.cancel(); + this.app.vault.offref(this.onFileModifyEventRef); + this.onFileModifyEventRef = void 0; + wasActive = true; + } + return wasActive; + } + clearAutoPull() { + if (this.timeoutIDPull) { + window.clearTimeout(this.timeoutIDPull); + this.timeoutIDPull = void 0; + return true; + } + return false; + } + clearAutoPush() { + if (this.timeoutIDPush) { + window.clearTimeout(this.timeoutIDPush); + this.timeoutIDPush = void 0; + return true; + } + return false; + } + async handleConflict(conflicted) { + this.setState(6 /* conflicted */); + this.localStorage.setConflict("true"); + let lines; + if (conflicted !== void 0) { + lines = [ + "# Conflicts", + "Please resolve them and commit them using the commands `Obsidian Git: Commit all changes` followed by `Obsidian Git: Push`", + "(This file will automatically be deleted before commit)", + "[[#Additional Instructions]] available below file list", + "", + ...conflicted.map((e) => { + const file = this.app.vault.getAbstractFileByPath(e); + if (file instanceof import_obsidian30.TFile) { + const link = this.app.metadataCache.fileToLinktext( + file, + "/" + ); + return `- [[${link}]]`; + } else { + return `- Not a file: ${e}`; + } + }), + ` +# Additional Instructions +I strongly recommend to use "Source mode" for viewing the conflicted files. For simple conflicts, in each file listed above replace every occurrence of the following text blocks with the desired text. + +\`\`\`diff +<<<<<<< HEAD + File changes in local repository +======= + File changes in remote repository +>>>>>>> origin/main +\`\`\`` + ]; + } + this.writeAndOpenFile(lines == null ? void 0 : lines.join("\n")); + } + async editRemotes() { + if (!await this.isAllInitialized()) + return; + const remotes = await this.gitManager.getRemotes(); + const nameModal = new GeneralModal({ + options: remotes, + placeholder: "Select or create a new remote by typing its name and selecting it" + }); + const remoteName = await nameModal.open(); + if (remoteName) { + const oldUrl = await this.gitManager.getRemoteUrl(remoteName); + const urlModal = new GeneralModal({ initialValue: oldUrl }); + const remoteURL = await urlModal.open(); + if (remoteURL) { + await this.gitManager.setRemote(remoteName, remoteURL); + return remoteName; + } + } + } + async selectRemoteBranch() { + let remotes = await this.gitManager.getRemotes(); + let selectedRemote; + if (remotes.length === 0) { + selectedRemote = await this.editRemotes(); + if (selectedRemote == void 0) { + remotes = await this.gitManager.getRemotes(); + } + } + const nameModal = new GeneralModal({ + options: remotes, + placeholder: "Select or create a new remote by typing its name and selecting it" + }); + const remoteName = selectedRemote != null ? selectedRemote : await nameModal.open(); + if (remoteName) { + this.displayMessage("Fetching remote branches"); + await this.gitManager.fetch(remoteName); + const branches = await this.gitManager.getRemoteBranches( + remoteName + ); + const branchModal = new GeneralModal({ + options: branches, + placeholder: "Select or create a new remote branch by typing its name and selecting it" + }); + return await branchModal.open(); + } + } + async removeRemote() { + if (!await this.isAllInitialized()) + return; + const remotes = await this.gitManager.getRemotes(); + const nameModal = new GeneralModal({ + options: remotes, + placeholder: "Select a remote" + }); + const remoteName = await nameModal.open(); + if (remoteName) { + this.gitManager.removeRemote(remoteName); + } + } + async writeAndOpenFile(text2) { + if (text2 !== void 0) { + await this.app.vault.adapter.write(this.conflictOutputFile, text2); + } + let fileIsAlreadyOpened = false; + this.app.workspace.iterateAllLeaves((leaf) => { + if (leaf.getDisplayText() != "" && this.conflictOutputFile.startsWith(leaf.getDisplayText())) { + fileIsAlreadyOpened = true; + } + }); + if (!fileIsAlreadyOpened) { + this.app.workspace.openLinkText(this.conflictOutputFile, "/", true); + } + } + // region: displaying / formatting messages + displayMessage(message, timeout = 4 * 1e3) { + var _a2; + (_a2 = this.statusBar) == null ? void 0 : _a2.displayMessage(message.toLowerCase(), timeout); + if (!this.settings.disablePopups) { + new import_obsidian30.Notice(message, 5 * 1e3); + } + console.log(`git obsidian message: ${message}`); + } + displayError(message, timeout = 10 * 1e3) { + var _a2; + if (message instanceof Errors.UserCanceledError) { + new import_obsidian30.Notice("Aborted"); + return; + } + message = message.toString(); + new import_obsidian30.Notice(message, timeout); + console.log(`git obsidian error: ${message}`); + (_a2 = this.statusBar) == null ? void 0 : _a2.displayMessage(message.toLowerCase(), timeout); + } +}; +/*! Bundled license information: + +ieee754/index.js: + (*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh *) + +buffer/index.js: + (*! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + *) + +safe-buffer/index.js: + (*! safe-buffer. MIT License. Feross Aboukhadijeh *) + +crc-32/crc32.js: + (*! crc32.js (C) 2014-present SheetJS -- http://sheetjs.com *) + +js-sha256/src/sha256.js: + (** + * [js-sha256]{@link https://github.com/emn178/js-sha256} + * + * @version 0.9.0 + * @author Chen, Yi-Cyuan [emn178@gmail.com] + * @copyright Chen, Yi-Cyuan 2014-2017 + * @license MIT + *) + +feather-icons/dist/feather.js: + (*! + Copyright (c) 2016 Jed Watson. + Licensed under the MIT License (MIT), see + http://jedwatson.github.io/classnames + *) +*/ diff --git a/.obsidian/plugins/obsidian-git/manifest.json b/.obsidian/plugins/obsidian-git/manifest.json new file mode 100644 index 0000000..f1797b1 --- /dev/null +++ b/.obsidian/plugins/obsidian-git/manifest.json @@ -0,0 +1,9 @@ +{ + "id": "obsidian-git", + "name": "Obsidian Git", + "description": "Backup your vault with Git.", + "isDesktopOnly": false, + "fundingUrl": "https://ko-fi.com/vinzent", + "js": "main.js", + "version": "2.20.6" +} diff --git a/.obsidian/plugins/obsidian-git/styles.css b/.obsidian/plugins/obsidian-git/styles.css new file mode 100644 index 0000000..39cdb13 --- /dev/null +++ b/.obsidian/plugins/obsidian-git/styles.css @@ -0,0 +1,507 @@ +@keyframes loading { + 0% { + transform: rotate(0deg); + } + + 100% { + transform: rotate(360deg); + } +} + +.workspace-leaf-content[data-type='git-view'] .view-content { + padding: 0; +} + +.workspace-leaf-content[data-type='git-history-view'] .view-content { + padding: 0; +} + +.loading>svg { + animation: 2s linear infinite loading; + transform-origin: 50% 50%; + display: inline-block; +} + +.obsidian-git-center { + margin: auto; + text-align: center; + width: 50%; +} + +.obsidian-git-textarea { + display: block; + margin-left: auto; + margin-right: auto; +} + +.obsidian-git-center-button { + display: block; + margin: 20px auto; +} + +.tooltip.mod-left { + overflow-wrap: break-word; +} + +.tooltip.mod-right { + overflow-wrap: break-word; +} +.git-tools { + display: flex; + margin-left: auto; +} +.git-tools .type { + padding-left: var(--size-2-1); + display: flex; + align-items: center; + justify-content: center; + width: 11px; +} + +.git-tools .type[data-type="M"] { + color: orange; +} +.git-tools .type[data-type="D"] { + color: red; +} +.git-tools .buttons { + display: flex; +} +.git-tools .buttons > * { + padding: 0 0; + height: auto; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-d-none { + display: none; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-wrapper { + text-align: left; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-file-header { + background-color: var(--background-primary); + border-bottom: 1px solid var(--interactive-accent); + font-family: var(--font-monospace); + height: 35px; + padding: 5px 10px; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-file-header, +.workspace-leaf-content[data-type="diff-view"] .d2h-file-stats { + display: -webkit-box; + display: -ms-flexbox; + display: flex; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-file-stats { + font-size: 14px; + margin-left: auto; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-lines-added { + border: 1px solid #b4e2b4; + border-radius: 5px 0 0 5px; + color: #399839; + padding: 2px; + text-align: right; + vertical-align: middle; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-lines-deleted { + border: 1px solid #e9aeae; + border-radius: 0 5px 5px 0; + color: #c33; + margin-left: 1px; + padding: 2px; + text-align: left; + vertical-align: middle; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-file-name-wrapper { + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + font-size: 15px; + width: 100%; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-file-name { + overflow-x: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-file-wrapper { + border: 1px solid var(--background-modifier-border); + border-radius: 3px; + margin-bottom: 1em; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-file-collapse { + -webkit-box-pack: end; + -ms-flex-pack: end; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + border: 1px solid var(--background-modifier-border); + border-radius: 3px; + cursor: pointer; + display: none; + font-size: 12px; + justify-content: flex-end; + padding: 4px 8px; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-file-collapse.d2h-selected { + background-color: #c8e1ff; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-file-collapse-input { + margin: 0 4px 0 0; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-diff-table { + border-collapse: collapse; + font-family: Menlo, Consolas, monospace; + font-size: 13px; + width: 100%; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-files-diff { + width: 100%; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-file-diff { + overflow-y: hidden; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-file-side-diff { + display: inline-block; + margin-bottom: -8px; + margin-right: -4px; + overflow-x: scroll; + overflow-y: hidden; + width: 50%; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-code-line { + padding: 0 8em; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-code-line, +.workspace-leaf-content[data-type="diff-view"] .d2h-code-side-line { + display: inline-block; + -webkit-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; + white-space: nowrap; + width: 100%; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-code-side-line { + padding: 0 4.5em; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-code-line-ctn { + word-wrap: normal; + background: none; + display: inline-block; + padding: 0; + -webkit-user-select: text; + -moz-user-select: text; + -ms-user-select: text; + user-select: text; + vertical-align: middle; + white-space: pre; + width: 100%; +} + +.theme-light .workspace-leaf-content[data-type="diff-view"] .d2h-code-line del, +.theme-light .workspace-leaf-content[data-type="diff-view"] .d2h-code-side-line del { + background-color: #ffb6ba; +} + +.theme-dark .workspace-leaf-content[data-type="diff-view"] .d2h-code-line del, +.theme-dark .workspace-leaf-content[data-type="diff-view"] .d2h-code-side-line del { + background-color: #8d232881; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-code-line del, +.workspace-leaf-content[data-type="diff-view"] .d2h-code-line ins, +.workspace-leaf-content[data-type="diff-view"] .d2h-code-side-line del, +.workspace-leaf-content[data-type="diff-view"] .d2h-code-side-line ins { + border-radius: 0.2em; + display: inline-block; + margin-top: -1px; + text-decoration: none; + vertical-align: middle; +} + +.theme-light .workspace-leaf-content[data-type="diff-view"] .d2h-code-line ins, +.theme-light .workspace-leaf-content[data-type="diff-view"] .d2h-code-side-line ins { + background-color: #97f295; + text-align: left; +} + +.theme-dark .workspace-leaf-content[data-type="diff-view"] .d2h-code-line ins, +.theme-dark .workspace-leaf-content[data-type="diff-view"] .d2h-code-side-line ins { + background-color: #1d921996; + text-align: left; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-code-line-prefix { + word-wrap: normal; + background: none; + display: inline; + padding: 0; + white-space: pre; +} + +.workspace-leaf-content[data-type="diff-view"] .line-num1 { + float: left; +} + +.workspace-leaf-content[data-type="diff-view"] .line-num1, +.workspace-leaf-content[data-type="diff-view"] .line-num2 { + -webkit-box-sizing: border-box; + box-sizing: border-box; + overflow: hidden; + padding: 0 0.5em; + text-overflow: ellipsis; + width: 3.5em; +} + +.workspace-leaf-content[data-type="diff-view"] .line-num2 { + float: right; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-code-linenumber { + background-color: var(--background-primary); + border: solid var(--background-modifier-border); + border-width: 0 1px; + -webkit-box-sizing: border-box; + box-sizing: border-box; + color: var(--text-muted); + cursor: pointer; + display: inline-block; + position: absolute; + text-align: right; + width: 7.5em; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-code-linenumber:after { + content: "\200b"; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-code-side-linenumber { + background-color: var(--background-primary); + border: solid var(--background-modifier-border); + border-width: 0 1px; + -webkit-box-sizing: border-box; + box-sizing: border-box; + color: var(--text-muted); + cursor: pointer; + display: inline-block; + overflow: hidden; + padding: 0 0.5em; + position: absolute; + text-align: right; + text-overflow: ellipsis; + width: 4em; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-diff-tbody tr { + position: relative; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-code-side-linenumber:after { + content: "\200b"; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-code-side-emptyplaceholder, +.workspace-leaf-content[data-type="diff-view"] .d2h-emptyplaceholder { + background-color: var(--background-primary); + border-color: var(--background-modifier-border); +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-code-line-prefix, +.workspace-leaf-content[data-type="diff-view"] .d2h-code-linenumber, +.workspace-leaf-content[data-type="diff-view"] .d2h-code-side-linenumber, +.workspace-leaf-content[data-type="diff-view"] .d2h-emptyplaceholder { + -webkit-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-code-linenumber, +.workspace-leaf-content[data-type="diff-view"] .d2h-code-side-linenumber { + direction: rtl; +} + +.theme-light .workspace-leaf-content[data-type="diff-view"] .d2h-del { + background-color: #fee8e9; + border-color: #e9aeae; +} + +.theme-light .workspace-leaf-content[data-type="diff-view"] .d2h-ins { + background-color: #dfd; + border-color: #b4e2b4; +} + +.theme-dark .workspace-leaf-content[data-type="diff-view"] .d2h-del { + background-color: #521b1d83; + border-color: #691d1d73; +} + +.theme-dark .workspace-leaf-content[data-type="diff-view"] .d2h-ins { + background-color: rgba(30, 71, 30, 0.5); + border-color: #13501381; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-info { + background-color: var(--background-primary); + border-color: var(--background-modifier-border); + color: var(--text-normal); +} + +.theme-light .workspace-leaf-content[data-type="diff-view"] .d2h-file-diff .d2h-del.d2h-change { + background-color: #fdf2d0; +} + +.theme-dark .workspace-leaf-content[data-type="diff-view"] .d2h-file-diff .d2h-del.d2h-change { + background-color: #55492480; +} + +.theme-light .workspace-leaf-content[data-type="diff-view"] .d2h-file-diff .d2h-ins.d2h-change { + background-color: #ded; +} + +.theme-dark .workspace-leaf-content[data-type="diff-view"] .d2h-file-diff .d2h-ins.d2h-change { + background-color: rgba(37, 78, 37, 0.418); +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-file-list-wrapper { + margin-bottom: 10px; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-file-list-wrapper a { + color: #3572b0; + text-decoration: none; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-file-list-wrapper a:visited { + color: #3572b0; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-file-list-header { + text-align: left; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-file-list-title { + font-weight: 700; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-file-list-line { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + text-align: left; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-file-list { + display: block; + list-style: none; + margin: 0; + padding: 0; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-file-list>li { + border-bottom: 1px solid var(--background-modifier-border); + margin: 0; + padding: 5px 10px; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-file-list>li:last-child { + border-bottom: none; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-file-switch { + cursor: pointer; + display: none; + font-size: 10px; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-icon { + fill: currentColor; + margin-right: 10px; + vertical-align: middle; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-deleted { + color: #c33; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-added { + color: #399839; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-changed { + color: #d0b44c; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-moved { + color: #3572b0; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-tag { + background-color: var(--background-primary); + display: -webkit-box; + display: -ms-flexbox; + display: flex; + font-size: 10px; + margin-left: 5px; + padding: 0 2px; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-deleted-tag { + border: 2px solid #c33; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-added-tag { + border: 1px solid #399839; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-changed-tag { + border: 1px solid #d0b44c; +} + +.workspace-leaf-content[data-type="diff-view"] .d2h-moved-tag { + border: 1px solid #3572b0; +} + +/* ====================== Line Authoring Information ====================== */ + +.cm-gutterElement.obs-git-blame-gutter { + /* Add background color to spacing inbetween and around the gutter for better aesthetics */ + border-width: 0px 2px 0.2px 2px; + border-style: solid; + border-color: var(--background-secondary); + background-color: var(--background-secondary); +} + +.cm-gutterElement.obs-git-blame-gutter > div, .line-author-settings-preview { + /* delegate text color to settings */ + color: var(--obs-git-gutter-text); + font-family: monospace; + height: 100%; /* ensure, that age-based background color occupies entire parent */ + text-align: right; + padding: 0px 6px 0px 6px; + white-space: pre; /* Keep spaces and do not collapse them. */ +} diff --git a/.obsidian/plugins/obsidian-image-toolkit/main.js b/.obsidian/plugins/obsidian-image-toolkit/main.js new file mode 100644 index 0000000..d795731 --- /dev/null +++ b/.obsidian/plugins/obsidian-image-toolkit/main.js @@ -0,0 +1,3192 @@ +'use strict'; + +var obsidian = require('obsidian'); + +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ + +function __awaiter(thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +} + +// العربية +var ar = {}; + +// čeština +var cz = {}; + +// Dansk +var da = {}; + +// Deutsch +var de = {}; + +// English +var en = { + // settings + IMAGE_TOOLKIT_SETTINGS_TITLE: "Image Toolkit Settings", + // >>>View Trigger Settings: + VIEW_TRIGGER_SETTINGS: 'View Trigger Settings:', + VIEW_IMAGE_GLOBAL_NAME: 'Click and view an image globally', + VIEW_IMAGE_GLOBAL_DESC: 'You can zoom, rotate, drag, and invert it on the popup layer when clicking an image.', + VIEW_IMAGE_EDITOR_NAME: 'Click and view an image in the Editor Area', + VIEW_IMAGE_EDITOR_DESC: 'Turn on this option if you want to click and view an image in the Editor Area.', + // CPB = COMMUNITY_PLUGINS_BROWSER + VIEW_IMAGE_IN_CPB_NAME: 'Click and view an image in the Community Plugins browser', + VIEW_IMAGE_IN_CPB_DESC: 'Turn on this option if you want to click and view an image in the Community Plugins browser.', + VIEW_IMAGE_WITH_A_LINK_NAME: 'Click and view an image with a link', + VIEW_IMAGE_WITH_A_LINK_DESC: 'Turn on this option if you want to click and view an image with a link. (NOTE: The browser will be opened for you to visit the link and the image will be popped up for being viewed at the same time when you click the image.)', + VIEW_IMAGE_OTHER_NAME: 'Click and view in the other areas except the above', + VIEW_IMAGE_OTHER_DESC: 'Except for the above mentioned, it also supports other areas, e.g. flashcards.', + // >>> PIN_MODE_SETTINGS + PIN_MODE_SETTINGS: "Pin Mode Settings:", + PIN_MODE_NAME: "📌 Pin an image", + PIN_MODE_DESC: "You can pin an image onto the top of the screen. And have more options by right click. (press Esc to close the image where your mouse cursor is hovering)", + PIN_MAXIMUM_NAME: "The maximum image you can pin", + PIN_COVER_NAME: "Cover mode", + PIN_COVER_DESC: "After those pinned images reach maximum, you can cover the earliest pinned image when you click an image once again.", + // >>>View Detail Settings: + VIEW_DETAILS_SETTINGS: 'View Detail Settings:', + IMAGE_MOVE_SPEED_NAME: 'Set the moving speed of the image', + IMAGE_MOVE_SPEED_DESC: 'When you move an image on the popup layer by keyboard (up, down, left, right), the moving speed of the image can be set here.', + IMAGE_TIP_TOGGLE_NAME: "Display the image's zoom number", + IMAGE_TIP_TOGGLE_DESC: "Turn on this option if you want to display the zoom number when you zoom the image.", + IMG_FULL_SCREEN_MODE_NAME: 'Full-screen preview mode', + // preview mode options: + FIT: 'Fit', + FILL: 'Fill', + STRETCH: 'Stretch', + IMG_VIEW_BACKGROUND_COLOR_NAME: "Set the background color of the previewed image (Only support the image with transparent background)", + // >>>Image Border Settings: + IMAGE_BORDER_SETTINGS: 'Image Border Settings:', + IMAGE_BORDER_TOGGLE_NAME: "Display the image's border", + IMAGE_BORDER_TOGGLE_DESC: "The clicked image's border can be displayed after you exit previewing and close the popup layer.", + IMAGE_BORDER_WIDTH_NAME: "Set the image's border width", + IMAGE_BORDER_STYLE_NAME: "Set the image's border style", + IMAGE_BORDER_COLOR_NAME: "Set the image's border color", + // IMG_BORDER_WIDTH options: + THIN: 'thin', + MEDIUM: 'medium', + THICK: 'thick', + // IMG_BORDER_STYLE options: + //HIDDEN: 'hidden', + DOTTED: 'dotted', + DASHED: 'dashed', + SOLID: 'solid', + DOUBLE: 'double', + GROOVE: 'groove', + RIDGE: 'ridge', + INSET: 'inset', + OUTSET: 'outset', + // IMAGE_BORDER_COLOR_NAME options: + BLACK: 'black', + BLUE: 'blue', + DARK_GREEN: 'dark green', + GREEN: 'green', + LIME: 'lime', + STEEL_BLUE: 'steel blue', + INDIGO: 'indigo', + PURPLE: 'purple', + GRAY: 'gray', + DARK_RED: 'dark red', + LIGHT_GREEN: 'light green', + BROWN: 'brown', + LIGHT_BLUE: 'light blue', + SILVER: 'silver', + RED: 'red', + PINK: 'pink', + ORANGE: 'orange', + GOLD: 'gold', + YELLOW: 'yellow', + // >>>Gallery Navbar Settings: + GALLERY_NAVBAR_SETTINGS: 'Gallery Navbar Settings (Experimental):', + GALLERY_NAVBAR_TOGGLE_NAME: "Display gallery navbar", + GALLERY_NAVBAR_TOGGLE_DESC: "All of the images in the current pane view can be displayed at the bottom of the popup layer.", + GALLERY_NAVBAR_DEFAULT_COLOR_NAME: "Set the background color of the gallery navbar (default state)", + GALLERY_NAVBAR_HOVER_COLOR_NAME: "Set the background color of the gallery navbar (hovering state)", + GALLERY_IMG_BORDER_TOGGLE_NAME: "Display the selected image on the gallery navbar", + GALLERY_IMG_BORDER_TOGGLE_DESC: "When you select an image, the image's border will be displayed, so you can know which image is currently active.", + GALLERY_IMG_BORDER_ACTIVE_COLOR_NAME: 'Set the border color of the selected image', + // >>>HOTKEYS_SETTINGS: + HOTKEY_SETTINGS: "Hotkey Settings:", + HOTKEY_SETTINGS_DESC: "📢 You cannot set the same hotkey for 'Move the image' and 'Switch the image' at the same time. (NOT SUPPORT in Pin Mode)", + MOVE_THE_IMAGE_NAME: "Set the hotkey for moving the image", + MOVE_THE_IMAGE_DESC: "You can move the image on the popup layer by hotkey.", + SWITCH_THE_IMAGE_NAME: "Set the hotkey for switching the image", + SWITCH_THE_IMAGE_DESC: "You can switch to the previous/next image on the gallery navbar by hotkey. (NOTE: You need to turn on 'Display gallery navbar' first, if you wanna use this hotkey.)", + DOUBLE_CLICK_TOOLBAR_NAME: "Double click", + VIEW_TRIGGER_HOTKEY_NAME: "Set the hotkey for triggering viewing an image", + VIEW_TRIGGER_HOTKEY_DESC: "When you set 'None', you can directly click and preview an image without holding any modifier keys; otherwise, you must hold the configured modifier keys to click and preview an image.", + // MODIFIER_HOTKEYS + NONE: "None", + CTRL: "Ctrl", + ALT: "Alt", + SHIFT: "Shift", + CTRL_ALT: "Ctrl+Alt", + CTRL_SHIFT: "Ctrl+Shift", + SHIFT_ALT: "Shift+Alt", + CTRL_SHIFT_ALT: "Ctrl+Shift+Alt", + // toolbar icon title + ZOOM_TO_100: "zoom to 100%", + ZOOM_IN: "zoom in", + ZOOM_OUT: "zoom out", + FULL_SCREEN: 'full screen', + REFRESH: "refresh", + ROTATE_LEFT: "rotate left", + ROTATE_RIGHT: "rotate right", + SCALE_X: 'flip along x-axis', + SCALE_Y: 'flip along y-axis', + INVERT_COLOR: 'invert color', + COPY: 'copy', + CLOSE: 'close', + // tip: + COPY_IMAGE_SUCCESS: 'Copy the image successfully!', + COPY_IMAGE_ERROR: 'Fail to copy the image!' +}; + +// British English +var enGB = {}; + +// Español +var es = {}; + +// français +var fr = {}; + +// हिन्दी +var hi = {}; + +// Bahasa Indonesia +var id = {}; + +// Italiano +var it = {}; + +// 日本語 +var ja = {}; + +// 한국어 +var ko = {}; + +// Nederlands +var nl = {}; + +// Norsk +var no = {}; + +// język polski +var pl = {}; + +// Português +var pt = {}; + +// Português do Brasil +// Brazilian Portuguese +var ptBR = {}; + +// Română +var ro = {}; + +// русский +var ru = {}; + +// Türkçe +var tr = {}; + +// 简体中文 +var zhCN = { + // settings + IMAGE_TOOLKIT_SETTINGS_TITLE: "Image Toolkit 插件设置", + // >>> 预览触发配置： + VIEW_TRIGGER_SETTINGS: '预览触发配置：', + VIEW_IMAGE_GLOBAL_NAME: '支持全局预览图片', + VIEW_IMAGE_GLOBAL_DESC: '开启后，在任何地方点击图片都可以弹出预览界面，可对图片进行缩放、旋转、拖动、和反色等。', + VIEW_IMAGE_EDITOR_NAME: '支持在编辑区域预览图片', + VIEW_IMAGE_EDITOR_DESC: '开启后，支持在编辑区域，点击图片预览。', + // CPB = COMMUNITY_PLUGINS_BROWSER + VIEW_IMAGE_IN_CPB_NAME: '支持在社区插件页面预览图片', + VIEW_IMAGE_IN_CPB_DESC: '开启后，支持在社区插件页面，点击图片预览。', + VIEW_IMAGE_WITH_A_LINK_NAME: '支持预览带链接的图片', + VIEW_IMAGE_WITH_A_LINK_DESC: '开启后，支持点击带链接的图片（注意：点击该图片，会同时打开浏览器访问指定地址和弹出预览图片）', + VIEW_IMAGE_OTHER_NAME: '支持除上述其他地方来预览图片', + VIEW_IMAGE_OTHER_DESC: '除上述支持范围外，还支持一些其他区域，如flashcards。', + // >>> PIN_MODE_SETTINGS + PIN_MODE_SETTINGS: "贴图模式设置：", + PIN_MODE_NAME: "📌 将所点击的图片贴到屏幕上", + PIN_MODE_DESC: "你可以将当前所点击的图片贴到屏幕上，并且可以通过右击图片选择更多操作（按 Esc 关闭已贴图片的展示）", + PIN_MAXIMUM_NAME: "最大贴图数量", + PIN_COVER_NAME: "覆盖模式", + PIN_COVER_DESC: "当贴图数量达到最大值后，此时再次点击图片，该图片会覆盖最早弹出的那个贴图。", + // >>>查看细节设置： + VIEW_DETAILS_SETTINGS: '查看细节设置：', + IMAGE_MOVE_SPEED_NAME: '图片移动速度设置', + IMAGE_MOVE_SPEED_DESC: '当使用键盘（上、下、左、右）移动图片时，可对图片移动速度进行设置。', + IMAGE_TIP_TOGGLE_NAME: "展示缩放比例提示", + IMAGE_TIP_TOGGLE_DESC: "开启后，当你缩放图片时会展示当前缩放的比例。", + IMG_FULL_SCREEN_MODE_NAME: '全屏预览模式', + // 全屏预览模式 下拉： + FIT: '自适应', + FILL: '填充', + STRETCH: '拉伸', + IMG_VIEW_BACKGROUND_COLOR_NAME: "设置预览图片的背景色（仅对透明背景的图片生效）", + // >>>图片边框设置： + IMAGE_BORDER_SETTINGS: '图片边框设置：', + IMAGE_BORDER_TOGGLE_NAME: "展示被点击图片的边框", + IMAGE_BORDER_TOGGLE_DESC: "当离开图片预览和关闭弹出层后，突出展示被点击图片的边框。", + IMAGE_BORDER_WIDTH_NAME: "设置图片边框宽度", + IMAGE_BORDER_STYLE_NAME: "设置图片边框样式", + IMAGE_BORDER_COLOR_NAME: "设置图片边框颜色", + // IMG_BORDER_WIDTH 下拉： + THIN: '较细', + MEDIUM: '正常', + THICK: '较粗', + // IMG_BORDER_STYLE 下拉： + //HIDDEN: '隐藏', + DOTTED: '点状', + DASHED: '虚线', + SOLID: '实线', + DOUBLE: '双线', + GROOVE: '凹槽', + RIDGE: ' 垄状', + INSET: '凹边', + OUTSET: '凸边', + // IMAGE_BORDER_COLOR_NAME 下拉： + BLACK: '黑色', + BLUE: '蓝色', + DARK_GREEN: '深绿色', + GREEN: '绿色', + LIME: '淡黄绿色', + STEEL_BLUE: '钢青色', + INDIGO: '靛蓝色', + PURPLE: '紫色', + GRAY: '灰色', + DARK_RED: '深红色', + LIGHT_GREEN: '浅绿色', + BROWN: '棕色', + LIGHT_BLUE: '浅蓝色', + SILVER: '银色', + RED: '红色', + PINK: '粉红色', + ORANGE: '橘黄色', + GOLD: '金色', + YELLOW: '黄色', + // >>>Gallery Navbar Settings: + GALLERY_NAVBAR_SETTINGS: '图片导航设置 (体验版):', + GALLERY_NAVBAR_TOGGLE_NAME: "展示图片导航", + GALLERY_NAVBAR_TOGGLE_DESC: "当前文档的所有图片会展示在弹出层的底部，可随意切换展示不同图片。", + GALLERY_NAVBAR_DEFAULT_COLOR_NAME: "设置图片导航底栏背景色（默认展示）", + GALLERY_NAVBAR_HOVER_COLOR_NAME: "设置图片导航底栏背景色（鼠标悬浮时）", + GALLERY_IMG_BORDER_TOGGLE_NAME: "展示图片导航上被选中的图片", + GALLERY_IMG_BORDER_TOGGLE_DESC: "当你选中正查看某一图片，对应图片导航底栏上将突出显示该缩略图片的边框。", + GALLERY_IMG_BORDER_ACTIVE_COLOR_NAME: '设置被选中图片的边框色', + // >>>HOTKEYS_SETTINGS: + HOTKEY_SETTINGS: "快捷键设置:", + HOTKEY_SETTINGS_DESC: "📢 你无法为'移动图片'和'切换图片'设置相同的快捷键。（不支持贴图模式）", + MOVE_THE_IMAGE_NAME: "为移动图片设置快捷键", + MOVE_THE_IMAGE_DESC: "你可以利用快捷键来移动弹出层上的图片。", + SWITCH_THE_IMAGE_NAME: "为切换图片设置快捷键", + SWITCH_THE_IMAGE_DESC: "你可以利用快捷键来切换在图片导航栏上的图片至上一张/下一张。(注意: 仅当开启“展示图片导航”后，才能使用该快捷键来控制切换图片。)", + DOUBLE_CLICK_TOOLBAR_NAME: "双击", + VIEW_TRIGGER_HOTKEY_NAME: "为触发弹出查看图片设置快捷键", + VIEW_TRIGGER_HOTKEY_DESC: "当你设置为“无”，你可以直接点击预览图片；否则，须按住已配置的修改键（Ctrl、Alt、Shift）才能点击查看某个图片。", + // MODIFIER_HOTKEYS + NONE: "无", + // toolbar icon title + ZOOM_TO_100: "缩放至100%", + ZOOM_IN: "放大", + ZOOM_OUT: "缩小", + FULL_SCREEN: "全屏", + REFRESH: "刷新", + ROTATE_LEFT: "左旋", + ROTATE_RIGHT: "右旋", + SCALE_X: 'x轴翻转', + SCALE_Y: 'y轴翻转', + INVERT_COLOR: '反色', + COPY: '复制', + CLOSE: '关闭', + // tip: + COPY_IMAGE_SUCCESS: '拷贝图片成功！', + COPY_IMAGE_ERROR: '拷贝图片失败！' +}; + +// 繁體中文 +var zhTW = { + // settings + IMAGE_TOOLKIT_SETTINGS_TITLE: "image toolkit 設定", + // toolbar icon title + ZOOM_IN: "放大", + ZOOM_OUT: "縮小", + FULL_SCREEN: '全螢幕', + REFRESH: "重整", + ROTATE_LEFT: "向左旋轉", + ROTATE_RIGHT: "向右旋轉", + SCALE_X: 'x 軸縮放', + SCALE_Y: 'y 軸縮放', + INVERT_COLOR: '色彩反轉', + COPY: '複製', + COPY_IMAGE_SUCCESS: '成功複製圖片！' +}; + +const localeMap = { + ar, + cs: cz, + da, + de, + en, + "en-gb": enGB, + es, + fr, + hi, + id, + it, + ja, + ko, + nl, + nn: no, + pl, + pt, + "pt-br": ptBR, + ro, + ru, + tr, + "zh-cn": zhCN, + "zh-tw": zhTW, +}; +const locale = localeMap[obsidian.moment.locale()]; +function t(str) { + if (!locale) { + console.error("Error: Image toolkit locale not found", obsidian.moment.locale()); + } + return (locale && locale[str]) || en[str]; +} + +const ZOOM_FACTOR = 0.8; +const IMG_VIEW_MIN = 30; +const ICONS = [{ + id: 'zoom-to-100', + svg: ` 1:1 ` + }]; +const SEPARATOR_SYMBOL = "---"; +const TOOLBAR_CONF = [{ + title: "ZOOM_TO_100", + class: 'toolbar_zoom_to_100', + icon: 'zoom-to-100', + enableToolbarIcon: true, + enableMenu: true, + enableHotKey: true + }, { + title: "ZOOM_IN", + class: 'toolbar_zoom_in', + icon: 'zoom-in', + enableToolbarIcon: true, + enableMenu: false, + enableHotKey: true + }, { + title: "ZOOM_OUT", + class: 'toolbar_zoom_out', + icon: 'zoom-out', + enableToolbarIcon: true, + enableMenu: false, + enableHotKey: true + }, { + title: "FULL_SCREEN", + class: 'toolbar_full_screen', + icon: 'expand', + enableToolbarIcon: true, + enableMenu: true, + enableHotKey: true + }, { + title: "REFRESH", + class: 'toolbar_refresh', + icon: 'refresh-ccw', + enableToolbarIcon: true, + enableMenu: true, + enableHotKey: true + }, { + title: "ROTATE_LEFT", + class: 'toolbar_rotate_left', + icon: 'rotate-ccw', + enableToolbarIcon: true, + enableMenu: true, + enableHotKey: true + }, { + title: "ROTATE_RIGHT", + class: 'toolbar_rotate_right', + icon: 'rotate-cw', + enableToolbarIcon: true, + enableMenu: true, + enableHotKey: true + }, { + title: "SCALE_X", + class: 'toolbar_scale_x', + icon: 'move-horizontal', + enableToolbarIcon: true, + enableMenu: true, + enableHotKey: true + }, { + title: "SCALE_Y", + class: 'toolbar_scale_y', + icon: 'move-vertical', + enableToolbarIcon: true, + enableMenu: true, + enableHotKey: true + }, { + title: "INVERT_COLOR", + class: 'toolbar_invert_color', + icon: 'droplet', + enableToolbarIcon: true, + enableMenu: true, + enableHotKey: true + }, { + title: "COPY", + class: 'toolbar_copy', + icon: 'copy', + enableToolbarIcon: true, + enableMenu: true, + enableHotKey: true + }, { + title: SEPARATOR_SYMBOL, + enableToolbarIcon: false, + enableMenu: true, + enableHotKey: false + }, { + title: "CLOSE", + class: 'toolbar_close', + icon: 'trash', + enableToolbarIcon: false, + enableMenu: true, + enableHotKey: true + }]; +const IMG_FULL_SCREEN_MODE = { + FIT: 'FIT', + FILL: 'FILL', + STRETCH: 'STRETCH' +}; +const VIEW_IMG_SELECTOR = { + EDITOR_AREAS: `.workspace-leaf-content[data-type='markdown'] img,.workspace-leaf-content[data-type='image'] img`, + EDITOR_AREAS_NO_LINK: `.workspace-leaf-content[data-type='markdown'] img:not(a img),.workspace-leaf-content[data-type='image'] img:not(a img)`, + CPB: `.community-plugin-readme img`, + CPB_NO_LINK: `.community-plugin-readme img:not(a img)`, + OTHER: `#sr-flashcard-view img`, + OTHER_NO_LINK: `#sr-flashcard-view img:not(a img)`, +}; +const IMG_BORDER_WIDTH = { + THIN: 'thin', + MEDIUM: 'medium', + THICK: 'thick' +}; +const IMG_BORDER_STYLE = { + // HIDDEN: 'hidden', + DOTTED: 'dotted', + DASHED: 'dashed', + SOLID: 'solid', + DOUBLE: 'double', + GROOVE: 'groove', + RIDGE: 'ridge', + INSET: 'inset', + OUTSET: 'outset' +}; +// https://www.runoob.com/cssref/css-colorsfull.html +const IMG_BORDER_COLOR = { + BLACK: 'black', + BLUE: 'blue', + DARK_GREEN: 'darkgreen', + GREEN: 'green', + LIME: 'lime', + STEEL_BLUE: 'steelblue', + INDIGO: 'indigo', + PURPLE: 'purple', + GRAY: 'gray', + DARK_RED: 'darkred', + LIGHT_GREEN: 'lightgreen', + BROWN: 'brown', + LIGHT_BLUE: 'lightblue', + SILVER: 'silver', + RED: 'red', + PINK: 'pink', + ORANGE: 'orange', + GOLD: 'gold', + YELLOW: 'yellow' +}; +const GALLERY_NAVBAR_DEFAULT_COLOR = '#0000001A'; // rgba(0, 0, 0, 0.1) +const GALLERY_NAVBAR_HOVER_COLOR = '#0000004D'; // rgba(0, 0, 0, 0.3) +const GALLERY_IMG_BORDER_ACTIVE_COLOR = '#FF0000'; // red +const MODIFIER_HOTKEYS = { + NONE: "NONE", + CTRL: "CTRL", + ALT: "ALT", + SHIFT: "SHIFT", + CTRL_ALT: "CTRL_ALT", + CTRL_SHIFT: "CTRL_SHIFT", + SHIFT_ALT: "SHIFT_ALT", + CTRL_SHIFT_ALT: "CTRL_SHIFT_ALT" +}; +const MOVE_THE_IMAGE = { + CODE: "MOVE_THE_IMAGE", + DEFAULT_HOTKEY: MODIFIER_HOTKEYS.NONE, + SVG: `` +}; +const SWITCH_THE_IMAGE = { + CODE: "SWITCH_THE_IMAGE", + DEFAULT_HOTKEY: MODIFIER_HOTKEYS.CTRL, + SVG: `` +}; +const IMG_DEFAULT_BACKGROUND_COLOR = '#00000000'; + +function getDefaultExportFromCjs (x) { + return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x; +} + +function createCommonjsModule(fn) { + var module = { exports: {} }; + return fn(module, module.exports), module.exports; +} + +/*! Pickr 1.8.2 MIT | https://github.com/Simonwep/pickr */ + +var pickr_min = createCommonjsModule(function (module, exports) { +!function(t,e){module.exports=e();}(self,(function(){return (()=>{var t={d:(e,o)=>{for(var n in o)t.o(o,n)&&!t.o(e,n)&&Object.defineProperty(e,n,{enumerable:!0,get:o[n]});},o:(t,e)=>Object.prototype.hasOwnProperty.call(t,e),r:t=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0});}},e={};t.d(e,{default:()=>L});var o={};function n(t,e,o,n,i={}){e instanceof HTMLCollection||e instanceof NodeList?e=Array.from(e):Array.isArray(e)||(e=[e]),Array.isArray(o)||(o=[o]);for(const s of e)for(const e of o)s[t](e,n,{capture:!1,...i});return Array.prototype.slice.call(arguments,1)}t.r(o),t.d(o,{adjustableInputNumbers:()=>p,createElementFromString:()=>r,createFromTemplate:()=>a,eventPath:()=>l,off:()=>s,on:()=>i,resolveElement:()=>c});const i=n.bind(null,"addEventListener"),s=n.bind(null,"removeEventListener");function r(t){const e=document.createElement("div");return e.innerHTML=t.trim(),e.firstElementChild}function a(t){const e=(t,e)=>{const o=t.getAttribute(e);return t.removeAttribute(e),o},o=(t,n={})=>{const i=e(t,":obj"),s=e(t,":ref"),r=i?n[i]={}:n;s&&(n[s]=t);for(const n of Array.from(t.children)){const t=e(n,":arr"),i=o(n,t?{}:r);t&&(r[t]||(r[t]=[])).push(Object.keys(i).length?i:n);}return n};return o(r(t))}function l(t){let e=t.path||t.composedPath&&t.composedPath();if(e)return e;let o=t.target.parentElement;for(e=[t.target,o];o=o.parentElement;)e.push(o);return e.push(document,window),e}function c(t){return t instanceof Element?t:"string"==typeof t?t.split(/>>/g).reduce(((t,e,o,n)=>(t=t.querySelector(e),ot)){function o(o){const n=[.001,.01,.1][Number(o.shiftKey||2*o.ctrlKey)]*(o.deltaY<0?1:-1);let i=0,s=t.selectionStart;t.value=t.value.replace(/[\d.]+/g,((t,o)=>o<=s&&o+t.length>=s?(s=o,e(Number(t),n,i)):(i++,t))),t.focus(),t.setSelectionRange(s,s),o.preventDefault(),t.dispatchEvent(new Event("input"));}i(t,"focus",(()=>i(window,"wheel",o,{passive:!1}))),i(t,"blur",(()=>s(window,"wheel",o)));}const{min:u,max:h,floor:d,round:m}=Math;function f(t,e,o){e/=100,o/=100;const n=d(t=t/360*6),i=t-n,s=o*(1-e),r=o*(1-i*e),a=o*(1-(1-i)*e),l=n%6;return [255*[o,r,s,s,a,o][l],255*[a,o,o,r,s,s][l],255*[s,s,a,o,o,r][l]]}function v(t,e,o){const n=(2-(e/=100))*(o/=100)/2;return 0!==n&&(e=1===n?0:n<.5?e*o/(2*n):e*o/(2-2*n)),[t,100*e,100*n]}function b(t,e,o){const n=u(t/=255,e/=255,o/=255),i=h(t,e,o),s=i-n;let r,a;if(0===s)r=a=0;else {a=s/i;const n=((i-t)/6+s/2)/s,l=((i-e)/6+s/2)/s,c=((i-o)/6+s/2)/s;t===i?r=c-l:e===i?r=1/3+n-c:o===i&&(r=2/3+l-n),r<0?r+=1:r>1&&(r-=1);}return [360*r,100*a,100*i]}function y(t,e,o,n){e/=100,o/=100;return [...b(255*(1-u(1,(t/=100)*(1-(n/=100))+n)),255*(1-u(1,e*(1-n)+n)),255*(1-u(1,o*(1-n)+n)))]}function g(t,e,o){e/=100;const n=2*(e*=(o/=100)<.5?o:1-o)/(o+e)*100,i=100*(o+e);return [t,isNaN(n)?0:n,i]}function _(t){return b(...t.match(/.{2}/g).map((t=>parseInt(t,16))))}function w(t){t=t.match(/^[a-zA-Z]+$/)?function(t){if("black"===t.toLowerCase())return "#000";const e=document.createElement("canvas").getContext("2d");return e.fillStyle=t,"#000"===e.fillStyle?null:e.fillStyle}(t):t;const e={cmyk:/^cmyk[\D]+([\d.]+)[\D]+([\d.]+)[\D]+([\d.]+)[\D]+([\d.]+)/i,rgba:/^((rgba)|rgb)[\D]+([\d.]+)[\D]+([\d.]+)[\D]+([\d.]+)[\D]*?([\d.]+|$)/i,hsla:/^((hsla)|hsl)[\D]+([\d.]+)[\D]+([\d.]+)[\D]+([\d.]+)[\D]*?([\d.]+|$)/i,hsva:/^((hsva)|hsv)[\D]+([\d.]+)[\D]+([\d.]+)[\D]+([\d.]+)[\D]*?([\d.]+|$)/i,hexa:/^#?(([\dA-Fa-f]{3,4})|([\dA-Fa-f]{6})|([\dA-Fa-f]{8}))$/i},o=t=>t.map((t=>/^(|\d+)\.\d+|\d+$/.test(t)?Number(t):void 0));let n;t:for(const i in e){if(!(n=e[i].exec(t)))continue;const s=t=>!!n[2]==("number"==typeof t);switch(i){case"cmyk":{const[,t,e,s,r]=o(n);if(t>100||e>100||s>100||r>100)break t;return {values:y(t,e,s,r),type:i}}case"rgba":{const[,,,t,e,r,a]=o(n);if(t>255||e>255||r>255||a<0||a>1||!s(a))break t;return {values:[...b(t,e,r),a],a,type:i}}case"hexa":{let[,t]=n;4!==t.length&&3!==t.length||(t=t.split("").map((t=>t+t)).join(""));const e=t.substring(0,6);let o=t.substring(6);return o=o?parseInt(o,16)/255:void 0,{values:[..._(e),o],a:o,type:i}}case"hsla":{const[,,,t,e,r,a]=o(n);if(t>360||e>100||r>100||a<0||a>1||!s(a))break t;return {values:[...g(t,e,r),a],a,type:i}}case"hsva":{const[,,,t,e,r,a]=o(n);if(t>360||e>100||r>100||a<0||a>1||!s(a))break t;return {values:[t,e,r,a],a,type:i}}}}return {values:null,type:null}}function A(t=0,e=0,o=0,n=1){const i=(t,e)=>(o=-1)=>e(~o?t.map((t=>Number(t.toFixed(o)))):t),s={h:t,s:e,v:o,a:n,toHSVA(){const t=[s.h,s.s,s.v,s.a];return t.toString=i(t,(t=>`hsva(${t[0]}, ${t[1]}%, ${t[2]}%, ${s.a})`)),t},toHSLA(){const t=[...v(s.h,s.s,s.v),s.a];return t.toString=i(t,(t=>`hsla(${t[0]}, ${t[1]}%, ${t[2]}%, ${s.a})`)),t},toRGBA(){const t=[...f(s.h,s.s,s.v),s.a];return t.toString=i(t,(t=>`rgba(${t[0]}, ${t[1]}, ${t[2]}, ${s.a})`)),t},toCMYK(){const t=function(t,e,o){const n=f(t,e,o),i=n[0]/255,s=n[1]/255,r=n[2]/255,a=u(1-i,1-s,1-r);return [100*(1===a?0:(1-i-a)/(1-a)),100*(1===a?0:(1-s-a)/(1-a)),100*(1===a?0:(1-r-a)/(1-a)),100*a]}(s.h,s.s,s.v);return t.toString=i(t,(t=>`cmyk(${t[0]}%, ${t[1]}%, ${t[2]}%, ${t[3]}%)`)),t},toHEXA(){const t=function(t,e,o){return f(t,e,o).map((t=>m(t).toString(16).padStart(2,"0")))}(s.h,s.s,s.v),e=s.a>=1?"":Number((255*s.a).toFixed(0)).toString(16).toUpperCase().padStart(2,"0");return e&&t.push(e),t.toString=()=>`#${t.join("").toUpperCase()}`,t},clone:()=>A(s.h,s.s,s.v,s.a)};return s}const C=t=>Math.max(Math.min(t,1),0);function $(t){const e={options:Object.assign({lock:null,onchange:()=>0,onstop:()=>0},t),_keyboard(t){const{options:o}=e,{type:n,key:i}=t;if(document.activeElement===o.wrapper){const{lock:o}=e.options,s="ArrowUp"===i,r="ArrowRight"===i,a="ArrowDown"===i,l="ArrowLeft"===i;if("keydown"===n&&(s||r||a||l)){let n=0,i=0;"v"===o?n=s||r?1:-1:"h"===o?n=s||r?-1:1:(i=s?-1:a?1:0,n=l?-1:r?1:0),e.update(C(e.cache.x+.01*n),C(e.cache.y+.01*i)),t.preventDefault();}else i.startsWith("Arrow")&&(e.options.onstop(),t.preventDefault());}},_tapstart(t){i(document,["mouseup","touchend","touchcancel"],e._tapstop),i(document,["mousemove","touchmove"],e._tapmove),t.cancelable&&t.preventDefault(),e._tapmove(t);},_tapmove(t){const{options:o,cache:n}=e,{lock:i,element:s,wrapper:r}=o,a=r.getBoundingClientRect();let l=0,c=0;if(t){const e=t&&t.touches&&t.touches[0];l=t?(e||t).clientX:0,c=t?(e||t).clientY:0,la.left+a.width&&(l=a.left+a.width),ca.top+a.height&&(c=a.top+a.height),l-=a.left,c-=a.top;}else n&&(l=n.x*a.width,c=n.y*a.height);"h"!==i&&(s.style.left=`calc(${l/a.width*100}% - ${s.offsetWidth/2}px)`),"v"!==i&&(s.style.top=`calc(${c/a.height*100}% - ${s.offsetHeight/2}px)`),e.cache={x:l/a.width,y:c/a.height};const p=C(l/a.width),u=C(c/a.height);switch(i){case"v":return o.onchange(p);case"h":return o.onchange(u);default:return o.onchange(p,u)}},_tapstop(){e.options.onstop(),s(document,["mouseup","touchend","touchcancel"],e._tapstop),s(document,["mousemove","touchmove"],e._tapmove);},trigger(){e._tapmove();},update(t=0,o=0){const{left:n,top:i,width:s,height:r}=e.options.wrapper.getBoundingClientRect();"h"===e.options.lock&&(o=t),e._tapmove({clientX:n+s*t,clientY:i+r*o});},destroy(){const{options:t,_tapstart:o,_keyboard:n}=e;s(document,["keydown","keyup"],n),s([t.wrapper,t.element],"mousedown",o),s([t.wrapper,t.element],"touchstart",o,{passive:!1});}},{options:o,_tapstart:n,_keyboard:r}=e;return i([o.wrapper,o.element],"mousedown",n),i([o.wrapper,o.element],"touchstart",n,{passive:!1}),i(document,["keydown","keyup"],r),e}function k(t={}){t=Object.assign({onchange:()=>0,className:"",elements:[]},t);const e=i(t.elements,"click",(e=>{t.elements.forEach((o=>o.classList[e.target===o?"add":"remove"](t.className))),t.onchange(e),e.stopPropagation();}));return {destroy:()=>s(...e)}}const S={variantFlipOrder:{start:"sme",middle:"mse",end:"ems"},positionFlipOrder:{top:"tbrl",right:"rltb",bottom:"btrl",left:"lrbt"},position:"bottom",margin:8},O=(t,e,o)=>{const{container:n,margin:i,position:s,variantFlipOrder:r,positionFlipOrder:a}={container:document.documentElement.getBoundingClientRect(),...S,...o},{left:l,top:c}=e.style;e.style.left="0",e.style.top="0";const p=t.getBoundingClientRect(),u=e.getBoundingClientRect(),h={t:p.top-u.height-i,b:p.bottom+i,r:p.right+i,l:p.left-u.width-i},d={vs:p.left,vm:p.left+p.width/2+-u.width/2,ve:p.left+p.width-u.width,hs:p.top,hm:p.bottom-p.height/2-u.height/2,he:p.bottom-u.height},[m,f="middle"]=s.split("-"),v=a[m],b=r[f],{top:y,left:g,bottom:_,right:w}=n;for(const t of v){const o="t"===t||"b"===t,n=h[t],[i,s]=o?["top","left"]:["left","top"],[r,a]=o?[u.height,u.width]:[u.width,u.height],[l,c]=o?[_,w]:[w,_],[p,m]=o?[y,g]:[g,y];if(!(nl))for(const r of b){const l=d[(o?"v":"h")+r];if(!(lc))return e.style[s]=l-u[s]+"px",e.style[i]=n-u[i]+"px",t+r}}return e.style.left=l,e.style.top=c,null};function E(t,e,o){return e in t?Object.defineProperty(t,e,{value:o,enumerable:!0,configurable:!0,writable:!0}):t[e]=o,t}class L{constructor(t){E(this,"_initializingActive",!0),E(this,"_recalc",!0),E(this,"_nanopop",null),E(this,"_root",null),E(this,"_color",A()),E(this,"_lastColor",A()),E(this,"_swatchColors",[]),E(this,"_setupAnimationFrame",null),E(this,"_eventListener",{init:[],save:[],hide:[],show:[],clear:[],change:[],changestop:[],cancel:[],swatchselect:[]}),this.options=t=Object.assign({...L.DEFAULT_OPTIONS},t);const{swatches:e,components:o,theme:n,sliders:i,lockOpacity:s,padding:r}=t;["nano","monolith"].includes(n)&&!i&&(t.sliders="h"),o.interaction||(o.interaction={});const{preview:a,opacity:l,hue:c,palette:p}=o;o.opacity=!s&&l,o.palette=p||a||l||c,this._preBuild(),this._buildComponents(),this._bindEvents(),this._finalBuild(),e&&e.length&&e.forEach((t=>this.addSwatch(t)));const{button:u,app:h}=this._root;this._nanopop=((t,e,o)=>{const n="object"!=typeof t||t instanceof HTMLElement?{reference:t,popper:e,...o}:t;return {update(t=n){const{reference:e,popper:o}=Object.assign(n,t);if(!o||!e)throw new Error("Popper- or reference-element missing.");return O(e,o,n)}}})(u,h,{margin:r}),u.setAttribute("role","button"),u.setAttribute("aria-label",this._t("btn:toggle"));const d=this;this._setupAnimationFrame=requestAnimationFrame((function e(){if(!h.offsetWidth)return requestAnimationFrame(e);d.setColor(t.default),d._rePositioningPicker(),t.defaultRepresentation&&(d._representation=t.defaultRepresentation,d.setColorRepresentation(d._representation)),t.showAlways&&d.show(),d._initializingActive=!1,d._emit("init");}));}_preBuild(){const{options:t}=this;for(const e of ["el","container"])t[e]=c(t[e]);this._root=(t=>{const{components:e,useAsButton:o,inline:n,appClass:i,theme:s,lockOpacity:r}=t.options,l=t=>t?"":'style="display:none" hidden',c=e=>t._t(e),p=a(`\n
    \n\n ${o?"":''}\n\n
    \n
    \n
    \n \n
    \n
    \n\n
    \n
    \n
    \n
    \n\n
    \n
    \n
    \n
    \n\n
    \n
    \n
    \n
    \n
    \n\n
    \n\n
    \n \n\n \n \n \n \n \n\n \n \n \n
    \n
    \n
    \n `),u=p.interaction;return u.options.find((t=>!t.hidden&&!t.classList.add("active"))),u.type=()=>u.options.find((t=>t.classList.contains("active"))),p})(this),t.useAsButton&&(this._root.button=t.el),t.container.appendChild(this._root.root);}_finalBuild(){const t=this.options,e=this._root;if(t.container.removeChild(e.root),t.inline){const o=t.el.parentElement;t.el.nextSibling?o.insertBefore(e.app,t.el.nextSibling):o.appendChild(e.app);}else t.container.appendChild(e.app);t.useAsButton?t.inline&&t.el.remove():t.el.parentNode.replaceChild(e.root,t.el),t.disabled&&this.disable(),t.comparison||(e.button.style.transition="none",t.useAsButton||(e.preview.lastColor.style.transition="none")),this.hide();}_buildComponents(){const t=this,e=this.options.components,o=(t.options.sliders||"v").repeat(2),[n,i]=o.match(/^[vh]+$/g)?o:[],s=()=>this._color||(this._color=this._lastColor.clone()),r={palette:$({element:t._root.palette.picker,wrapper:t._root.palette.palette,onstop:()=>t._emit("changestop","slider",t),onchange(o,n){if(!e.palette)return;const i=s(),{_root:r,options:a}=t,{lastColor:l,currentColor:c}=r.preview;t._recalc&&(i.s=100*o,i.v=100-100*n,i.v<0&&(i.v=0),t._updateOutput("slider"));const p=i.toRGBA().toString(0);this.element.style.background=p,this.wrapper.style.background=`\n linear-gradient(to top, rgba(0, 0, 0, ${i.a}), transparent),\n linear-gradient(to left, hsla(${i.h}, 100%, 50%, ${i.a}), rgba(255, 255, 255, ${i.a}))\n `,a.comparison?a.useAsButton||t._lastColor||l.style.setProperty("--pcr-color",p):(r.button.style.setProperty("--pcr-color",p),r.button.classList.remove("clear"));const u=i.toHEXA().toString();for(const{el:e,color:o}of t._swatchColors)e.classList[u===o.toHEXA().toString()?"add":"remove"]("pcr-active");c.style.setProperty("--pcr-color",p);}}),hue:$({lock:"v"===i?"h":"v",element:t._root.hue.picker,wrapper:t._root.hue.slider,onstop:()=>t._emit("changestop","slider",t),onchange(o){if(!e.hue||!e.palette)return;const n=s();t._recalc&&(n.h=360*o),this.element.style.backgroundColor=`hsl(${n.h}, 100%, 50%)`,r.palette.trigger();}}),opacity:$({lock:"v"===n?"h":"v",element:t._root.opacity.picker,wrapper:t._root.opacity.slider,onstop:()=>t._emit("changestop","slider",t),onchange(o){if(!e.opacity||!e.palette)return;const n=s();t._recalc&&(n.a=Math.round(100*o)/100),this.element.style.background=`rgba(0, 0, 0, ${n.a})`,r.palette.trigger();}}),selectable:k({elements:t._root.interaction.options,className:"active",onchange(e){t._representation=e.target.getAttribute("data-type").toUpperCase(),t._recalc&&t._updateOutput("swatch");}})};this._components=r;}_bindEvents(){const{_root:t,options:e}=this,o=[i(t.interaction.clear,"click",(()=>this._clearColor())),i([t.interaction.cancel,t.preview.lastColor],"click",(()=>{this.setHSVA(...(this._lastColor||this._color).toHSVA(),!0),this._emit("cancel");})),i(t.interaction.save,"click",(()=>{!this.applyColor()&&!e.showAlways&&this.hide();})),i(t.interaction.result,["keyup","input"],(t=>{this.setColor(t.target.value,!0)&&!this._initializingActive&&(this._emit("change",this._color,"input",this),this._emit("changestop","input",this)),t.stopImmediatePropagation();})),i(t.interaction.result,["focus","blur"],(t=>{this._recalc="blur"===t.type,this._recalc&&this._updateOutput(null);})),i([t.palette.palette,t.palette.picker,t.hue.slider,t.hue.picker,t.opacity.slider,t.opacity.picker],["mousedown","touchstart"],(()=>this._recalc=!0),{passive:!0})];if(!e.showAlways){const n=e.closeWithKey;o.push(i(t.button,"click",(()=>this.isOpen()?this.hide():this.show())),i(document,"keyup",(t=>this.isOpen()&&(t.key===n||t.code===n)&&this.hide())),i(document,["touchstart","mousedown"],(e=>{this.isOpen()&&!l(e).some((e=>e===t.app||e===t.button))&&this.hide();}),{capture:!0}));}if(e.adjustableNumbers){const e={rgba:[255,255,255,1],hsva:[360,100,100,1],hsla:[360,100,100,1],cmyk:[100,100,100,100]};p(t.interaction.result,((t,o,n)=>{const i=e[this.getColorRepresentation().toLowerCase()];if(i){const e=i[n],s=t+(e>=100?1e3*o:o);return s<=0?0:Number((s{n.isOpen()&&(e.closeOnScroll&&n.hide(),null===t?(t=setTimeout((()=>t=null),100),requestAnimationFrame((function e(){n._rePositioningPicker(),null!==t&&requestAnimationFrame(e);}))):(clearTimeout(t),t=setTimeout((()=>t=null),100)));}),{capture:!0}));}this._eventBindings=o;}_rePositioningPicker(){const{options:t}=this;if(!t.inline){if(!this._nanopop.update({container:document.body.getBoundingClientRect(),position:t.position})){const t=this._root.app,e=t.getBoundingClientRect();t.style.top=(window.innerHeight-e.height)/2+"px",t.style.left=(window.innerWidth-e.width)/2+"px";}}}_updateOutput(t){const{_root:e,_color:o,options:n}=this;if(e.interaction.type()){const t=`to${e.interaction.type().getAttribute("data-type")}`;e.interaction.result.value="function"==typeof o[t]?o[t]().toString(n.outputPrecision):"";}!this._initializingActive&&this._recalc&&this._emit("change",o,t,this);}_clearColor(t=!1){const{_root:e,options:o}=this;o.useAsButton||e.button.style.setProperty("--pcr-color","rgba(0, 0, 0, 0.15)"),e.button.classList.add("clear"),o.showAlways||this.hide(),this._lastColor=null,this._initializingActive||t||(this._emit("save",null),this._emit("clear"));}_parseLocalColor(t){const{values:e,type:o,a:n}=w(t),{lockOpacity:i}=this.options,s=void 0!==n&&1!==n;return e&&3===e.length&&(e[3]=void 0),{values:!e||i&&s?null:e,type:o}}_t(t){return this.options.i18n[t]||L.I18N_DEFAULTS[t]}_emit(t,...e){this._eventListener[t].forEach((t=>t(...e,this)));}on(t,e){return this._eventListener[t].push(e),this}off(t,e){const o=this._eventListener[t]||[],n=o.indexOf(e);return ~n&&o.splice(n,1),this}addSwatch(t){const{values:e}=this._parseLocalColor(t);if(e){const{_swatchColors:t,_root:o}=this,n=A(...e),s=r(`