diff --git a/.obsidian/community-plugins.json b/.obsidian/community-plugins.json index ce0cd9f..e1d9519 100644 --- a/.obsidian/community-plugins.json +++ b/.obsidian/community-plugins.json @@ -1,5 +1,8 @@ [ "obsidian-git", "obsidian-tasks-plugin", - "pdf-plus" + "pdf-plus", + "advanced-canvas", + "obsidian-plantuml", + "tasks-calendar-wrapper" ] \ No newline at end of file diff --git a/.obsidian/core-plugins.json b/.obsidian/core-plugins.json index 3f2ab43..639b90d 100644 --- a/.obsidian/core-plugins.json +++ b/.obsidian/core-plugins.json @@ -28,5 +28,6 @@ "file-recovery": true, "publish": false, "sync": true, - "bases": true + "bases": true, + "webviewer": false } \ No newline at end of file diff --git a/.obsidian/plugins/advanced-canvas/main.js b/.obsidian/plugins/advanced-canvas/main.js new file mode 100644 index 0000000..0d90e25 --- /dev/null +++ b/.obsidian/plugins/advanced-canvas/main.js @@ -0,0 +1,7552 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ESBUILD +if you want to view the source, please visit the github repository of this plugin +*/ + +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// src/main.ts +var main_exports = {}; +__export(main_exports, { + default: () => AdvancedCanvasPlugin +}); +module.exports = __toCommonJS(main_exports); +var import_obsidian19 = require("obsidian"); + +// src/utils/icons-helper.ts +var import_obsidian = require("obsidian"); +var CUSTOM_ICONS = { + "shape-pill": ``, + "shape-parallelogram": ``, + "shape-predefined-process": ` + + + + + + `, + "shape-document": ``, + "shape-database": ` + + + + + `, + "border-solid": ``, + "border-dashed": ``, + "border-dotted": ``, + "path-solid": ``, + "path-dotted": ``, + "path-short-dashed": ``, + "path-long-dashed": ``, + "arrow-triangle": ``, + "arrow-triangle-outline": ``, + "arrow-thin-triangle": ``, + "arrow-halved-triangle": ``, + "arrow-diamond": ``, + "arrow-diamond-outline": ``, + "arrow-circle": ``, + "arrow-circle-outline": ``, + "pathfinding-method-bezier": ``, + "pathfinding-method-square": ``, + "arrows-selected": ` + + + + + + + + + + `, + "arrow-right-selected": ` + + + + + + + + `, + "arrow-left-selected": ` + + + + + + + + ` +}; +var IconsHelper = class { + static addIcons() { + for (const [id, svg] of Object.entries(CUSTOM_ICONS)) { + (0, import_obsidian.addIcon)(id, svg); + } + } +}; + +// src/utils/debug-helper.ts +var DebugHelper = class { + constructor(plugin) { + this.logging = true; + this.nodeAddedCount = 0; + this.nodeChangedCount = 0; + this.edgeAddedCount = 0; + this.edgeChangedCount = 0; + this.plugin = plugin; + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:canvas-changed", + (_canvas) => { + this.nodeAddedCount = 0; + this.nodeChangedCount = 0; + this.edgeAddedCount = 0; + this.edgeChangedCount = 0; + } + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-added", + (_canvas, _node) => { + if (this.logging) console.count("\u{1F7E2} NodeAdded"); + this.nodeAddedCount++; + } + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-changed", + (_canvas, _node) => { + if (this.logging) console.count("\u{1F7E1} NodeChanged"); + this.nodeChangedCount++; + } + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:edge-added", + (_canvas, _edge) => { + if (this.logging) console.count("\u{1F7E2} EdgeAdded"); + this.edgeAddedCount++; + } + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:edge-changed", + (_canvas, _edge) => { + if (this.logging) console.count("\u{1F7E1} EdgeChanged"); + this.edgeChangedCount++; + } + )); + } + resetEfficiency() { + this.nodeAddedCount = 0; + this.nodeChangedCount = 0; + this.edgeAddedCount = 0; + this.edgeChangedCount = 0; + } + logEfficiency() { + const canvas = this.plugin.getCurrentCanvas(); + if (!canvas) return; + console.log("NodeAdded Efficiency:", this.nodeAddedCount / canvas.nodes.size); + console.log("NodeChanged Efficiency:", this.nodeChangedCount / canvas.nodes.size); + console.log("EdgeAdded Efficiency:", this.edgeAddedCount / canvas.edges.size); + console.log("EdgeChanged Efficiency:", this.edgeChangedCount / canvas.edges.size); + } + static markBBox(canvas, bbox, duration = -1) { + const node = canvas.createTextNode({ + pos: { x: bbox.minX, y: bbox.minY }, + size: { width: bbox.maxX - bbox.minX, height: bbox.maxY - bbox.minY }, + text: "", + focus: false + }); + node.setData({ + ...node.getData(), + id: "debug-bbox", + color: "1", + styleAttributes: { + border: "invisible" + } + }); + if (duration >= 0) { + setTimeout(() => { + canvas.removeNode(node); + }, duration); + } + } +}; + +// src/settings.ts +var import_obsidian4 = require("obsidian"); + +// src/utils/bbox-helper.ts +var BBoxHelper = class { + static combineBBoxes(bboxes) { + let minX = Infinity; + let minY = Infinity; + let maxX = -Infinity; + let maxY = -Infinity; + for (const bbox of bboxes) { + minX = Math.min(minX, bbox.minX); + minY = Math.min(minY, bbox.minY); + maxX = Math.max(maxX, bbox.maxX); + maxY = Math.max(maxY, bbox.maxY); + } + return { minX, minY, maxX, maxY }; + } + static scaleBBox(bbox, scale) { + const diffX = (scale - 1) * (bbox.maxX - bbox.minX); + const diffY = (scale - 1) * (bbox.maxY - bbox.minY); + return { + minX: bbox.minX - diffX / 2, + maxX: bbox.maxX + diffX / 2, + minY: bbox.minY - diffY / 2, + maxY: bbox.maxY + diffY / 2 + }; + } + static isColliding(bbox1, bbox2) { + return bbox1.minX <= bbox2.maxX && bbox1.maxX >= bbox2.minX && bbox1.minY <= bbox2.maxY && bbox1.maxY >= bbox2.minY; + } + static insideBBox(position, bbox, canTouchEdge) { + if ("x" in position) { + const x = position.x, y = position.y; + return canTouchEdge ? x >= bbox.minX && x <= bbox.maxX && y >= bbox.minY && y <= bbox.maxY : x > bbox.minX && x < bbox.maxX && y > bbox.minY && y < bbox.maxY; + } + return canTouchEdge ? position.minX >= bbox.minX && position.maxX <= bbox.maxX && position.minY >= bbox.minY && position.maxY <= bbox.maxY : position.minX > bbox.minX && position.maxX < bbox.maxX && position.minY > bbox.minY && position.maxY < bbox.maxY; + } + static enlargeBBox(bbox, padding) { + return { + minX: bbox.minX - padding, + minY: bbox.minY - padding, + maxX: bbox.maxX + padding, + maxY: bbox.maxY + padding + }; + } + static moveInDirection(position, side, distance) { + switch (side) { + case "top": + return { x: position.x, y: position.y - distance }; + case "right": + return { x: position.x + distance, y: position.y }; + case "bottom": + return { x: position.x, y: position.y + distance }; + case "left": + return { x: position.x - distance, y: position.y }; + } + } + static getCenterOfBBoxSide(bbox, side) { + switch (side) { + case "top": + return { x: (bbox.minX + bbox.maxX) / 2, y: bbox.minY }; + case "right": + return { x: bbox.maxX, y: (bbox.minY + bbox.maxY) / 2 }; + case "bottom": + return { x: (bbox.minX + bbox.maxX) / 2, y: bbox.maxY }; + case "left": + return { x: bbox.minX, y: (bbox.minY + bbox.maxY) / 2 }; + } + } + static getSideVector(side) { + switch (side) { + case "top": + return { x: 0, y: 1 }; + case "right": + return { x: 1, y: 0 }; + case "bottom": + return { x: 0, y: -1 }; + case "left": + return { x: -1, y: 0 }; + default: + return { x: 0, y: 0 }; + } + } + static getOppositeSide(side) { + switch (side) { + case "top": + return "bottom"; + case "right": + return "left"; + case "bottom": + return "top"; + case "left": + return "right"; + } + } + static isHorizontal(side) { + return side === "left" || side === "right"; + } + static direction(side) { + return side === "right" || side === "bottom" ? 1 : -1; + } +}; + +// src/utils/canvas-helper.ts +var import_obsidian2 = require("obsidian"); +var _CanvasHelper = class _CanvasHelper { + static canvasCommand(plugin, check, run) { + return (checking) => { + const canvas = plugin.getCurrentCanvas(); + if (checking) return canvas !== null && check(canvas); + if (canvas) run(canvas); + return true; + }; + } + static createControlMenuButton(menuOption) { + const quickSetting = document.createElement("div"); + if (menuOption.id) quickSetting.id = menuOption.id; + quickSetting.classList.add("canvas-control-item"); + (0, import_obsidian2.setIcon)(quickSetting, menuOption.icon); + (0, import_obsidian2.setTooltip)(quickSetting, menuOption.label, { placement: "left" }); + quickSetting.addEventListener("click", () => { + var _a; + return (_a = menuOption.callback) == null ? void 0 : _a.call(menuOption); + }); + return quickSetting; + } + static addControlMenuButton(controlGroup, element) { + var _a; + if (element.id) (_a = controlGroup.querySelector(`#${element.id}`)) == null ? void 0 : _a.remove(); + controlGroup.appendChild(element); + } + static createCardMenuOption(canvas, menuOption, previewNodeSize, onPlaced) { + const menuOptionElement = document.createElement("div"); + if (menuOption.id) menuOptionElement.id = menuOption.id; + menuOptionElement.classList.add("canvas-card-menu-button"); + menuOptionElement.classList.add("mod-draggable"); + (0, import_obsidian2.setIcon)(menuOptionElement, menuOption.icon); + (0, import_obsidian2.setTooltip)(menuOptionElement, menuOption.label, { placement: "top" }); + menuOptionElement.addEventListener("click", (_e) => { + onPlaced(canvas, this.getCenterCoordinates(canvas, previewNodeSize())); + }); + menuOptionElement.addEventListener("pointerdown", (e) => { + canvas.dragTempNode(e, previewNodeSize(), (pos) => { + canvas.deselectAll(); + onPlaced(canvas, pos); + }); + }); + return menuOptionElement; + } + static addCardMenuOption(canvas, element) { + var _a; + if (element.id) (_a = canvas == null ? void 0 : canvas.cardMenuEl.querySelector(`#${element.id}`)) == null ? void 0 : _a.remove(); + canvas == null ? void 0 : canvas.cardMenuEl.appendChild(element); + } + static createPopupMenuOption(menuOption) { + const menuOptionElement = document.createElement("button"); + if (menuOption.id) menuOptionElement.id = menuOption.id; + menuOptionElement.classList.add("clickable-icon"); + (0, import_obsidian2.setIcon)(menuOptionElement, menuOption.icon); + (0, import_obsidian2.setTooltip)(menuOptionElement, menuOption.label, { placement: "top" }); + menuOptionElement.addEventListener("click", () => { + var _a; + return (_a = menuOption.callback) == null ? void 0 : _a.call(menuOption); + }); + return menuOptionElement; + } + static createExpandablePopupMenuOption(menuOption, subMenuOptions) { + const menuOptionElement = this.createPopupMenuOption({ + ...menuOption, + callback: () => { + var _a, _b, _c; + const submenuId = `${menuOption.id}-submenu`; + if (menuOptionElement.classList.contains("is-active")) { + menuOptionElement.classList.remove("is-active"); + (_b = (_a = menuOptionElement.parentElement) == null ? void 0 : _a.querySelector(`#${submenuId}`)) == null ? void 0 : _b.remove(); + return; + } + menuOptionElement.classList.add("is-active"); + const submenu = document.createElement("div"); + submenu.id = submenuId; + submenu.classList.add("canvas-submenu"); + for (const subMenuOption of subMenuOptions) { + const subMenuOptionElement = this.createPopupMenuOption(subMenuOption); + submenu.appendChild(subMenuOptionElement); + } + (_c = menuOptionElement.parentElement) == null ? void 0 : _c.appendChild(submenu); + } + }); + return menuOptionElement; + } + static addPopupMenuOption(canvas, element, index = -1) { + var _a; + const popupMenuEl = (_a = canvas == null ? void 0 : canvas.menu) == null ? void 0 : _a.menuEl; + if (!popupMenuEl) return; + if (element.id) { + const optionToReplace = popupMenuEl.querySelector(`#${element.id}`); + if (optionToReplace && index === -1) index = Array.from(popupMenuEl.children).indexOf(optionToReplace) - 1; + optionToReplace == null ? void 0 : optionToReplace.remove(); + } + const sisterElement = index >= 0 ? popupMenuEl.children[index] : popupMenuEl.children[popupMenuEl.children.length + index]; + popupMenuEl.insertAfter(element, sisterElement); + } + static getCenterCoordinates(canvas, nodeSize) { + const viewBounds = canvas.getViewportBBox(); + return { + x: (viewBounds.minX + viewBounds.maxX) / 2 - nodeSize.width / 2, + y: (viewBounds.minY + viewBounds.maxY) / 2 - nodeSize.height / 2 + }; + } + static getBBox(canvasElements) { + const bBoxes = canvasElements.map((element) => { + if (element.getBBox) return element.getBBox(); + const nodeData = element; + if (nodeData.x !== void 0 && nodeData.y !== void 0 && nodeData.width !== void 0 && nodeData.height !== void 0) + return { minX: nodeData.x, minY: nodeData.y, maxX: nodeData.x + nodeData.width, maxY: nodeData.y + nodeData.height }; + return null; + }).filter((bbox) => bbox !== null); + return BBoxHelper.combineBBoxes(bBoxes); + } + static getSmallestAllowedZoomBBox(canvas, bbox) { + if (canvas.screenshotting) return bbox; + if (canvas.canvasRect.width === 0 || canvas.canvasRect.height === 0) return bbox; + const widthZoom = canvas.canvasRect.width / (bbox.maxX - bbox.minX); + const heightZoom = canvas.canvasRect.height / (bbox.maxY - bbox.minY); + const requiredZoom = Math.min(widthZoom, heightZoom); + if (requiredZoom > _CanvasHelper.MAX_ALLOWED_ZOOM) { + const scaleFactor = requiredZoom / _CanvasHelper.MAX_ALLOWED_ZOOM; + return BBoxHelper.scaleBBox(bbox, scaleFactor); + } + return bbox; + } + static addStyleAttributesToPopup(plugin, canvas, styleAttributes, currentStyleAttributes, setStyleAttribute) { + if (!plugin.settings.getSetting("combineCustomStylesInDropdown")) + this.addStyleAttributesButtons(canvas, styleAttributes, currentStyleAttributes, setStyleAttribute); + else this.addStyleAttributesDropdownMenu(canvas, styleAttributes, currentStyleAttributes, setStyleAttribute); + } + static addStyleAttributesButtons(canvas, stylableAttributes, currentStyleAttributes, setStyleAttribute) { + var _a; + for (const stylableAttribute of stylableAttributes) { + const selectedStyle = (_a = stylableAttribute.options.find((option) => currentStyleAttributes[stylableAttribute.key] === option.value)) != null ? _a : stylableAttribute.options.find((value) => value.value === null); + if (!selectedStyle) { + console.warn(`No "null" style option found for stylable attribute "${stylableAttribute.key}"`); + continue; + } + const menuOption = _CanvasHelper.createExpandablePopupMenuOption({ + id: `menu-option-${stylableAttribute.key}`, + label: stylableAttribute.label, + icon: selectedStyle.icon + }, stylableAttribute.options.map((styleOption) => ({ + label: styleOption.label, + icon: styleOption.icon, + callback: () => { + setStyleAttribute(stylableAttribute, styleOption.value); + currentStyleAttributes[stylableAttribute.key] = styleOption.value; + (0, import_obsidian2.setIcon)(menuOption, styleOption.icon); + menuOption.dispatchEvent(new Event("click")); + } + }))); + _CanvasHelper.addPopupMenuOption(canvas, menuOption); + } + } + static addStyleAttributesDropdownMenu(canvas, stylableAttributes, currentStyleAttributes, setStyleAttribute) { + var _a, _b; + const STYLE_MENU_ID = "style-menu"; + const STYLE_MENU_DROPDOWN_ID = "style-menu-dropdown"; + const STYLE_MENU_DROPDOWN_SUBMENU_ID = "style-menu-dropdown-submenu"; + const popupMenuElement = (_a = canvas == null ? void 0 : canvas.menu) == null ? void 0 : _a.menuEl; + if (!popupMenuElement) return; + (_b = popupMenuElement.querySelector(`#${STYLE_MENU_ID}`)) == null ? void 0 : _b.remove(); + const styleMenuButtonElement = document.createElement("button"); + styleMenuButtonElement.id = STYLE_MENU_ID; + styleMenuButtonElement.classList.add("clickable-icon"); + (0, import_obsidian2.setIcon)(styleMenuButtonElement, "paintbrush"); + (0, import_obsidian2.setTooltip)(styleMenuButtonElement, "Style", { placement: "top" }); + popupMenuElement.appendChild(styleMenuButtonElement); + styleMenuButtonElement.addEventListener("click", () => { + var _a2, _b2, _c; + const isOpen = styleMenuButtonElement.classList.toggle("has-active-menu"); + if (!isOpen) { + (_a2 = popupMenuElement.querySelector(`#${STYLE_MENU_DROPDOWN_ID}`)) == null ? void 0 : _a2.remove(); + (_b2 = popupMenuElement.querySelector(`#${STYLE_MENU_DROPDOWN_SUBMENU_ID}`)) == null ? void 0 : _b2.remove(); + return; + } + const styleMenuDropdownElement = document.createElement("div"); + styleMenuDropdownElement.id = STYLE_MENU_DROPDOWN_ID; + styleMenuDropdownElement.classList.add("menu"); + styleMenuDropdownElement.style.position = "absolute"; + styleMenuDropdownElement.style.maxHeight = "initial"; + styleMenuDropdownElement.style.top = `${popupMenuElement.getBoundingClientRect().height}px`; + const canvasWrapperCenterX = canvas.wrapperEl.getBoundingClientRect().left + canvas.wrapperEl.getBoundingClientRect().width / 2; + const leftPosition = styleMenuButtonElement.getBoundingClientRect().left - popupMenuElement.getBoundingClientRect().left; + const rightPosition = popupMenuElement.getBoundingClientRect().right - styleMenuButtonElement.getBoundingClientRect().right; + if (popupMenuElement.getBoundingClientRect().left + leftPosition < canvasWrapperCenterX) + styleMenuDropdownElement.style.left = `${leftPosition}px`; + else styleMenuDropdownElement.style.right = `${rightPosition}px`; + for (const stylableAttribute of stylableAttributes) { + const stylableAttributeElement = document.createElement("div"); + stylableAttributeElement.classList.add("menu-item"); + stylableAttributeElement.classList.add("tappable"); + const iconElement = document.createElement("div"); + iconElement.classList.add("menu-item-icon"); + let selectedStyle = (_c = stylableAttribute.options.find((option) => currentStyleAttributes[stylableAttribute.key] === option.value)) != null ? _c : stylableAttribute.options.find((value) => value.value === null); + if (!selectedStyle) continue; + (0, import_obsidian2.setIcon)(iconElement, selectedStyle.icon); + stylableAttributeElement.appendChild(iconElement); + const labelElement = document.createElement("div"); + labelElement.classList.add("menu-item-title"); + labelElement.textContent = stylableAttribute.label; + stylableAttributeElement.appendChild(labelElement); + const expandIconElement = document.createElement("div"); + expandIconElement.classList.add("menu-item-icon"); + (0, import_obsidian2.setIcon)(expandIconElement, "chevron-right"); + stylableAttributeElement.appendChild(expandIconElement); + styleMenuDropdownElement.appendChild(stylableAttributeElement); + stylableAttributeElement.addEventListener("pointerenter", () => { + stylableAttributeElement.classList.add("selected"); + }); + stylableAttributeElement.addEventListener("pointerleave", () => { + stylableAttributeElement.classList.remove("selected"); + }); + stylableAttributeElement.addEventListener("click", () => { + var _a3; + (_a3 = popupMenuElement.querySelector(`#${STYLE_MENU_DROPDOWN_SUBMENU_ID}`)) == null ? void 0 : _a3.remove(); + const styleMenuDropdownSubmenuElement = document.createElement("div"); + styleMenuDropdownSubmenuElement.id = STYLE_MENU_DROPDOWN_SUBMENU_ID; + styleMenuDropdownSubmenuElement.classList.add("menu"); + styleMenuDropdownSubmenuElement.style.position = "absolute"; + styleMenuDropdownSubmenuElement.style.maxHeight = "initial"; + const topOffset = parseFloat(window.getComputedStyle(styleMenuDropdownElement).getPropertyValue("padding-top")) + (styleMenuDropdownElement.offsetHeight - styleMenuDropdownElement.clientHeight) / 2; + styleMenuDropdownSubmenuElement.style.top = `${stylableAttributeElement.getBoundingClientRect().top - topOffset - popupMenuElement.getBoundingClientRect().top}px`; + const leftPosition2 = styleMenuDropdownElement.getBoundingClientRect().right - popupMenuElement.getBoundingClientRect().left; + const rightPosition2 = popupMenuElement.getBoundingClientRect().right - styleMenuDropdownElement.getBoundingClientRect().left; + if (popupMenuElement.getBoundingClientRect().left + leftPosition2 < canvasWrapperCenterX) + styleMenuDropdownSubmenuElement.style.left = `${leftPosition2}px`; + else styleMenuDropdownSubmenuElement.style.right = `${rightPosition2}px`; + for (const styleOption of stylableAttribute.options) { + const styleMenuDropdownSubmenuOptionElement = this.createDropdownOptionElement({ + label: styleOption.label, + icon: styleOption.icon, + callback: () => { + setStyleAttribute(stylableAttribute, styleOption.value); + currentStyleAttributes[stylableAttribute.key] = styleOption.value; + selectedStyle = styleOption; + (0, import_obsidian2.setIcon)(iconElement, styleOption.icon); + styleMenuDropdownSubmenuElement.remove(); + } + }); + if (selectedStyle === styleOption) { + styleMenuDropdownSubmenuOptionElement.classList.add("mod-selected"); + const selectedIconElement = document.createElement("div"); + selectedIconElement.classList.add("menu-item-icon"); + selectedIconElement.classList.add("mod-selected"); + (0, import_obsidian2.setIcon)(selectedIconElement, "check"); + styleMenuDropdownSubmenuOptionElement.appendChild(selectedIconElement); + } + styleMenuDropdownSubmenuElement.appendChild(styleMenuDropdownSubmenuOptionElement); + } + popupMenuElement.appendChild(styleMenuDropdownSubmenuElement); + }); + } + popupMenuElement.appendChild(styleMenuDropdownElement); + }); + } + static createDropdownOptionElement(menuOption) { + const menuDropdownOptionElement = document.createElement("div"); + menuDropdownOptionElement.classList.add("menu-item"); + menuDropdownOptionElement.classList.add("tappable"); + const iconElement = document.createElement("div"); + iconElement.classList.add("menu-item-icon"); + (0, import_obsidian2.setIcon)(iconElement, menuOption.icon); + menuDropdownOptionElement.appendChild(iconElement); + const labelElement = document.createElement("div"); + labelElement.classList.add("menu-item-title"); + labelElement.textContent = menuOption.label; + menuDropdownOptionElement.appendChild(labelElement); + menuDropdownOptionElement.addEventListener("pointerenter", () => { + menuDropdownOptionElement.classList.add("selected"); + }); + menuDropdownOptionElement.addEventListener("pointerleave", () => { + menuDropdownOptionElement.classList.remove("selected"); + }); + menuDropdownOptionElement.addEventListener("click", () => { + var _a; + (_a = menuOption.callback) == null ? void 0 : _a.call(menuOption); + }); + return menuDropdownOptionElement; + } + static createDropdownSeparatorElement() { + const separatorElement = document.createElement("div"); + separatorElement.classList.add("menu-separator"); + return separatorElement; + } + static alignToGrid(value, gridSize = this.GRID_SIZE) { + return Math.round(value / gridSize) * gridSize; + } + static getBestSideForFloatingEdge(sourcePos, target) { + const targetBBox = target.getBBox(); + const possibleSides = ["top", "right", "bottom", "left"]; + const possibleTargetPos = possibleSides.map((side) => [side, BBoxHelper.getCenterOfBBoxSide(targetBBox, side)]); + let bestSide = null; + let bestDistance = Infinity; + for (const [side, pos] of possibleTargetPos) { + const distance = Math.sqrt(Math.pow(sourcePos.x - pos.x, 2) + Math.pow(sourcePos.y - pos.y, 2)); + if (distance < bestDistance) { + bestDistance = distance; + bestSide = side; + } + } + return bestSide; + } + static selectEdgesForNodes(canvas, direction) { + const selection = canvas.getSelectionData(); + if (selection.nodes.length === 0) return; + const edges = /* @__PURE__ */ new Set(); + for (const nodeData of selection.nodes) { + const node = canvas.nodes.get(nodeData.id); + if (!node) continue; + for (const edge of canvas.getEdgesForNode(node)) { + switch (direction) { + case "connected": + edges.add(edge); + break; + case "incoming": + if (edge.to.node === node) edges.add(edge); + break; + case "outgoing": + if (edge.from.node === node) edges.add(edge); + break; + } + } + } + canvas.updateSelection(() => { + canvas.selection = edges; + }); + } +}; +_CanvasHelper.GRID_SIZE = 20; +_CanvasHelper.MAX_ALLOWED_ZOOM = 1; +var CanvasHelper = _CanvasHelper; + +// src/canvas-extensions/canvas-extension.ts +var CanvasExtension = class { + constructor(plugin) { + this.plugin = plugin; + const isEnabled = this.isEnabled(); + if (!(isEnabled === true || this.plugin.settings.getSetting(isEnabled))) return; + this.init(); + } +}; + +// src/utils/svg-path-helper.ts +var SvgPathHelper = class { + static smoothenPathArray(positions, tension) { + let newPositions = [...positions]; + if (positions.length <= 2) return newPositions; + newPositions = [positions[0]]; + for (let i = 1; i < positions.length - 2; i++) { + const p1 = positions[i]; + const p2 = positions[i + 1]; + const p3 = positions[i + 2]; + const t1 = (1 - tension) / 2; + const t2 = 1 - t1; + const x = t2 * t2 * t2 * p1.x + 3 * t2 * t2 * t1 * p2.x + 3 * t2 * t1 * t1 * p3.x + t1 * t1 * t1 * p2.x; + const y = t2 * t2 * t2 * p1.y + 3 * t2 * t2 * t1 * p2.y + 3 * t2 * t1 * t1 * p3.y + t1 * t1 * t1 * p2.y; + newPositions.push({ x, y }); + } + const lastPoint = positions[positions.length - 1]; + newPositions.push(lastPoint); + return newPositions; + } + static pathArrayToSvgPath(positions) { + for (let i = 0; i < positions.length - 2; i++) { + const p1 = positions[i]; + const p2 = positions[i + 1]; + const p3 = positions[i + 2]; + const currentDirection = { + x: p2.x - p1.x, + y: p2.y - p1.y + }; + const nextDirection = { + x: p3.x - p2.x, + y: p3.y - p2.y + }; + if (currentDirection.x !== nextDirection.x && currentDirection.y !== nextDirection.y) continue; + positions.splice(i + 1, 1); + i--; + } + return positions.map( + (position, index) => `${index === 0 ? "M" : "L"} ${position.x} ${position.y}` + ).join(" "); + } + static pathArrayToRoundedSvgPath(pathArray, targetRadius) { + if (pathArray.length < 3) + return this.pathArrayToSvgPath(pathArray); + pathArray = pathArray.filter((position, index) => { + if (index === 0) return true; + const previous = pathArray[index - 1]; + return !(position.x === previous.x && position.y === previous.y); + }); + const commands = []; + commands.push(`M ${pathArray[0].x} ${pathArray[0].y}`); + for (let i = 1; i < pathArray.length - 1; i++) { + const previous = pathArray[i - 1]; + const current = pathArray[i]; + const next = pathArray[i + 1]; + const prevDelta = { x: current.x - previous.x, y: current.y - previous.y }; + const nextDelta = { x: next.x - current.x, y: next.y - current.y }; + const prevLen = Math.sqrt(prevDelta.x * prevDelta.x + prevDelta.y * prevDelta.y); + const nextLen = Math.sqrt(nextDelta.x * nextDelta.x + nextDelta.y * nextDelta.y); + const prevUnit = prevLen ? { x: prevDelta.x / prevLen, y: prevDelta.y / prevLen } : { x: 0, y: 0 }; + const nextUnit = nextLen ? { x: nextDelta.x / nextLen, y: nextDelta.y / nextLen } : { x: 0, y: 0 }; + let dot = prevUnit.x * nextUnit.x + prevUnit.y * nextUnit.y; + dot = Math.max(-1, Math.min(1, dot)); + const angle = Math.acos(dot); + if (angle < 0.01 || Math.abs(Math.PI - angle) < 0.01) { + commands.push(`L ${current.x} ${current.y}`); + continue; + } + const desiredOffset = targetRadius * Math.tan(angle / 2); + const d = Math.min(desiredOffset, prevLen / 2, nextLen / 2); + const effectiveRadius = d / Math.tan(angle / 2); + const firstAnchor = { + x: current.x - prevUnit.x * d, + y: current.y - prevUnit.y * d + }; + const secondAnchor = { + x: current.x + nextUnit.x * d, + y: current.y + nextUnit.y * d + }; + commands.push(`L ${firstAnchor.x} ${firstAnchor.y}`); + const cross = prevDelta.x * nextDelta.y - prevDelta.y * nextDelta.x; + const sweepFlag = cross < 0 ? 0 : 1; + commands.push(`A ${effectiveRadius} ${effectiveRadius} 0 0 ${sweepFlag} ${secondAnchor.x} ${secondAnchor.y}`); + } + const last = pathArray[pathArray.length - 1]; + commands.push(`L ${last.x} ${last.y}`); + return commands.join(" "); + } +}; + +// src/canvas-extensions/advanced-styles/edge-pathfinding-methods/edge-pathfinding-method.ts +var EdgePathfindingMethod = class { + constructor(plugin, canvas, fromNodeBBox, fromPos, fromBBoxSidePos, fromSide, toNodeBBox, toPos, toBBoxSidePos, toSide) { + this.plugin = plugin; + this.canvas = canvas; + this.fromNodeBBox = fromNodeBBox; + this.fromPos = fromPos; + this.fromBBoxSidePos = fromBBoxSidePos; + this.fromSide = fromSide; + this.toNodeBBox = toNodeBBox; + this.toPos = toPos; + this.toBBoxSidePos = toBBoxSidePos; + this.toSide = toSide; + } +}; + +// src/canvas-extensions/advanced-styles/edge-pathfinding-methods/pathfinding-a-star.ts +var MAX_MS_CALCULATION = 100; +var BASIC_DIRECTIONS = [ + { dx: 1, dy: 0 }, + { dx: -1, dy: 0 }, + { dx: 0, dy: 1 }, + { dx: 0, dy: -1 } +]; +var DIAGONAL_DIRECTIONS = [ + { dx: 1, dy: 1 }, + { dx: -1, dy: 1 }, + { dx: 1, dy: -1 }, + { dx: -1, dy: -1 } +]; +var DIAGONAL_COST = Math.sqrt(2); +var ROUND_PATH_RADIUS = 5; +var SMOOTHEN_PATH_TENSION = 0.2; +var Node = class { + constructor(x, y) { + this.x = x; + this.y = y; + this.gCost = 0; + this.hCost = 0; + this.fCost = 0; + this.parent = null; + } + // Only check for x and y, not gCost, hCost, fCost, or parent + inList(nodes) { + return nodes.some((n) => n.x === this.x && n.y === this.y); + } +}; +var EdgePathfindingAStar = class extends EdgePathfindingMethod { + getPath() { + const nodeBBoxes = [...this.canvas.nodes.values()].filter((node) => { + const nodeData = node.getData(); + if (nodeData.portal === true) return false; + const nodeBBox = node.getBBox(); + const nodeContainsFromPos = BBoxHelper.insideBBox(this.fromPos, nodeBBox, true); + const nodeContainsToPos = BBoxHelper.insideBBox(this.toPos, nodeBBox, true); + return !nodeContainsFromPos && !nodeContainsToPos; + }).map((node) => node.getBBox()); + const fromPosWithMargin = BBoxHelper.moveInDirection(this.fromPos, this.fromSide, 10); + const toPosWithMargin = BBoxHelper.moveInDirection(this.toPos, this.toSide, 10); + const allowDiagonal = this.plugin.settings.getSetting("edgeStylePathfinderAllowDiagonal"); + const pathArray = this.aStarAlgorithm(fromPosWithMargin, toPosWithMargin, nodeBBoxes, CanvasHelper.GRID_SIZE / 2, allowDiagonal); + if (!pathArray) return null; + pathArray.splice(0, 0, this.fromPos); + pathArray.splice(pathArray.length, 0, this.toPos); + let svgPath; + const roundPath = this.plugin.settings.getSetting("edgeStylePathfinderPathRounded"); + if (roundPath) { + if (allowDiagonal) + svgPath = SvgPathHelper.pathArrayToSvgPath(SvgPathHelper.smoothenPathArray(pathArray, SMOOTHEN_PATH_TENSION)); + else + svgPath = SvgPathHelper.pathArrayToRoundedSvgPath(pathArray, ROUND_PATH_RADIUS); + } else svgPath = SvgPathHelper.pathArrayToSvgPath(pathArray); + return { + svgPath, + center: pathArray[Math.floor(pathArray.length / 2)], + rotateArrows: false + }; + } + aStarAlgorithm(fromPos, toPos, obstacles, gridResolution, allowDiagonal) { + const start = new Node( + Math.floor(fromPos.x / gridResolution) * gridResolution, + Math.floor(fromPos.y / gridResolution) * gridResolution + ); + if (this.fromSide === "right" && fromPos.x !== start.x) start.x += gridResolution; + if (this.fromSide === "bottom" && fromPos.y !== start.y) start.y += gridResolution; + const end = new Node( + Math.floor(toPos.x / gridResolution) * gridResolution, + Math.floor(toPos.y / gridResolution) * gridResolution + ); + if (this.toSide === "right" && toPos.x !== end.x) end.x += gridResolution; + if (this.toSide === "bottom" && toPos.y !== end.y) end.y += gridResolution; + if (this.isInsideObstacle(start, obstacles) || this.isInsideObstacle(end, obstacles)) return null; + const openSet = [start]; + const closedSet = []; + const startTimestamp = performance.now(); + while (openSet.length > 0) { + let current = null; + let lowestFCost = Infinity; + for (const node of openSet) { + if (node.fCost < lowestFCost) { + current = node; + lowestFCost = node.fCost; + } + } + if (performance.now() - startTimestamp > MAX_MS_CALCULATION) + return null; + if (!current) + return null; + openSet.splice(openSet.indexOf(current), 1); + closedSet.push(current); + if (current.x === end.x && current.y === end.y) + return [fromPos, ...this.reconstructPath(current), toPos].map((node) => ({ x: node.x, y: node.y })); + if (!(current.x === start.x && current.y === start.y) && this.isTouchingObstacle(current, obstacles)) + continue; + for (const neighbor of this.getPossibleNeighbors(current, obstacles, gridResolution, allowDiagonal)) { + if (neighbor.inList(closedSet)) + continue; + const tentativeGCost = current.gCost + (allowDiagonal ? this.getMovementCost({ + dx: neighbor.x - current.x, + dy: neighbor.y - current.y + }) : 1); + if (!neighbor.inList(openSet) || tentativeGCost < neighbor.gCost) { + neighbor.parent = current; + neighbor.gCost = tentativeGCost; + neighbor.hCost = this.heuristic(neighbor, end); + neighbor.fCost = neighbor.gCost + neighbor.hCost; + openSet.push(neighbor); + } + } + } + return null; + } + // Manhattan distance + heuristic(node, end) { + return Math.abs(node.x - end.x) + Math.abs(node.y - end.y); + } + // Define a function to check if a position isn't inside any obstacle + isTouchingObstacle(node, obstacles) { + return obstacles.some((obstacle) => BBoxHelper.insideBBox(node, obstacle, true)); + } + isInsideObstacle(node, obstacles) { + return obstacles.some((obstacle) => BBoxHelper.insideBBox(node, obstacle, false)); + } + // Define a function to calculate movement cost based on direction + getMovementCost(direction) { + return direction.dx !== 0 && direction.dy !== 0 ? DIAGONAL_COST : 1; + } + getPossibleNeighbors(node, obstacles, gridResolution, allowDiagonal) { + const neighbors = []; + const availableDirections = allowDiagonal ? [...BASIC_DIRECTIONS, ...DIAGONAL_DIRECTIONS] : BASIC_DIRECTIONS; + for (const direction of availableDirections) { + const neighbor = new Node( + node.x + direction.dx * gridResolution, + node.y + direction.dy * gridResolution + ); + neighbor.gCost = node.gCost + this.getMovementCost(direction); + if (this.isInsideObstacle(neighbor, obstacles)) continue; + neighbors.push(neighbor); + } + return neighbors; + } + reconstructPath(node) { + const path = []; + while (node) { + path.push(node); + node = node.parent; + } + return path.reverse(); + } +}; + +// src/canvas-extensions/advanced-styles/edge-pathfinding-methods/pathfinding-direct.ts +var EdgePathfindingDirect = class extends EdgePathfindingMethod { + getPath() { + return { + svgPath: SvgPathHelper.pathArrayToSvgPath([this.fromPos, this.toPos]), + center: { + x: (this.fromPos.x + this.toPos.x) / 2, + y: (this.fromPos.y + this.toPos.y) / 2 + }, + rotateArrows: true + }; + } +}; + +// src/canvas-extensions/advanced-styles/edge-pathfinding-methods/pathfinding-square.ts +var ROUNDED_EDGE_RADIUS = 5; +var EdgePathfindingSquare = class extends EdgePathfindingMethod { + getPath() { + const pathArray = []; + let center = { + x: (this.fromPos.x + this.toPos.x) / 2, + y: (this.fromPos.y + this.toPos.y) / 2 + }; + const idealCenter = BBoxHelper.isHorizontal(this.fromSide) ? { + x: this.toBBoxSidePos.x, + y: this.fromBBoxSidePos.y + } : { + x: this.fromBBoxSidePos.x, + y: this.toBBoxSidePos.y + }; + const isPathCollidingAtFrom = this.fromSide === "top" && idealCenter.y > this.fromPos.y || this.fromSide === "bottom" && idealCenter.y < this.fromPos.y || this.fromSide === "left" && idealCenter.x > this.fromPos.x || this.fromSide === "right" && idealCenter.x < this.fromPos.x; + const isPathCollidingAtTo = this.toSide === "top" && idealCenter.y > this.toPos.y || this.toSide === "bottom" && idealCenter.y < this.toPos.y || this.toSide === "left" && idealCenter.x > this.toPos.x || this.toSide === "right" && idealCenter.x < this.toPos.x; + if (this.fromSide === this.toSide) { + const uPath = this.getUPath(this.fromPos, this.toPos, this.fromSide, this.toSide); + pathArray.push(...uPath.pathArray); + center = uPath.center; + } else if (BBoxHelper.isHorizontal(this.fromSide) === BBoxHelper.isHorizontal(this.toSide)) { + let zPath; + if (!isPathCollidingAtFrom || !isPathCollidingAtTo) { + zPath = this.getZPath(this.fromPos, this.toPos, this.fromSide, this.toSide); + pathArray.push(...zPath.pathArray); + } else { + const fromDirection = BBoxHelper.direction(this.fromSide); + const firstFromDetourPoint = BBoxHelper.isHorizontal(this.fromSide) ? { + x: CanvasHelper.alignToGrid(this.fromBBoxSidePos.x + fromDirection * CanvasHelper.GRID_SIZE), + y: this.fromBBoxSidePos.y + } : { + x: this.fromBBoxSidePos.x, + y: CanvasHelper.alignToGrid(this.fromBBoxSidePos.y + fromDirection * CanvasHelper.GRID_SIZE) + }; + const toDirection = BBoxHelper.direction(this.toSide); + const firstToDetourPoint = BBoxHelper.isHorizontal(this.toSide) ? { + x: CanvasHelper.alignToGrid(this.toBBoxSidePos.x + toDirection * CanvasHelper.GRID_SIZE), + y: this.toBBoxSidePos.y + } : { + x: this.toBBoxSidePos.x, + y: CanvasHelper.alignToGrid(this.toBBoxSidePos.y + toDirection * CanvasHelper.GRID_SIZE) + }; + const newFromSide = BBoxHelper.isHorizontal(this.fromSide) ? firstFromDetourPoint.y < this.fromPos.y ? "top" : "bottom" : firstFromDetourPoint.x < firstToDetourPoint.x ? "right" : "left"; + zPath = this.getZPath(firstFromDetourPoint, firstToDetourPoint, newFromSide, BBoxHelper.getOppositeSide(newFromSide)); + pathArray.push(this.fromPos); + pathArray.push(...zPath.pathArray); + pathArray.push(this.toPos); + } + center = zPath.center; + } else { + if (isPathCollidingAtFrom || isPathCollidingAtTo) { + if (isPathCollidingAtFrom && isPathCollidingAtTo) { + const direction = BBoxHelper.direction(this.fromSide); + let firstFromDetourPoint; + let secondFromDetourPoint; + if (BBoxHelper.isHorizontal(this.fromSide)) { + const combinedBBoxes = BBoxHelper.combineBBoxes([this.fromNodeBBox, this.toNodeBBox]); + firstFromDetourPoint = { + x: CanvasHelper.alignToGrid((direction > 0 ? combinedBBoxes.maxX : combinedBBoxes.minX) + direction * CanvasHelper.GRID_SIZE), + y: this.fromBBoxSidePos.y + }; + secondFromDetourPoint = { + x: firstFromDetourPoint.x, + y: BBoxHelper.getCenterOfBBoxSide(this.fromNodeBBox, this.toSide).y + }; + } else { + const combinedBBoxes = BBoxHelper.combineBBoxes([this.fromNodeBBox, this.toNodeBBox]); + firstFromDetourPoint = { + x: this.fromBBoxSidePos.x, + y: CanvasHelper.alignToGrid((direction > 0 ? combinedBBoxes.maxY : combinedBBoxes.minY) + direction * CanvasHelper.GRID_SIZE) + }; + secondFromDetourPoint = { + x: BBoxHelper.getCenterOfBBoxSide(this.fromNodeBBox, this.toSide).x, + y: firstFromDetourPoint.y + }; + } + const uPath = this.getUPath(secondFromDetourPoint, this.toPos, this.toSide, this.toSide); + pathArray.push(this.fromPos); + pathArray.push(firstFromDetourPoint); + pathArray.push(...uPath.pathArray); + center = pathArray[Math.floor(pathArray.length / 2)]; + } else { + if (isPathCollidingAtFrom) { + const direction = BBoxHelper.direction(this.fromSide); + const firstFromDetourPoint = BBoxHelper.isHorizontal(this.fromSide) ? { + x: CanvasHelper.alignToGrid(this.fromBBoxSidePos.x + direction * CanvasHelper.GRID_SIZE), + y: this.fromBBoxSidePos.y + } : { + x: this.fromBBoxSidePos.x, + y: CanvasHelper.alignToGrid(this.fromBBoxSidePos.y + direction * CanvasHelper.GRID_SIZE) + }; + const useUPath = BBoxHelper.isHorizontal(this.fromSide) ? this.toPos.y > BBoxHelper.getCenterOfBBoxSide(this.fromNodeBBox, BBoxHelper.getOppositeSide(this.toSide)).y === BBoxHelper.direction(this.toSide) > 0 : this.toPos.x > BBoxHelper.getCenterOfBBoxSide(this.fromNodeBBox, BBoxHelper.getOppositeSide(this.toSide)).x === BBoxHelper.direction(this.toSide) > 0; + const connectionSide = useUPath ? this.toSide : BBoxHelper.getOppositeSide(this.toSide); + const secondFromDetourPoint = BBoxHelper.isHorizontal(this.fromSide) ? { + x: firstFromDetourPoint.x, + y: BBoxHelper.getCenterOfBBoxSide(this.fromNodeBBox, connectionSide).y + } : { + x: BBoxHelper.getCenterOfBBoxSide(this.fromNodeBBox, connectionSide).x, + y: firstFromDetourPoint.y + }; + const path = useUPath ? this.getUPath(secondFromDetourPoint, this.toPos, this.toSide, this.toSide) : this.getZPath(secondFromDetourPoint, this.toPos, this.toSide, this.toSide); + pathArray.push(this.fromPos); + pathArray.push(firstFromDetourPoint); + pathArray.push(...path.pathArray); + center = path.center; + } + if (isPathCollidingAtTo) { + const direction = BBoxHelper.direction(this.toSide); + const firstToDetourPoint = BBoxHelper.isHorizontal(this.toSide) ? { + x: CanvasHelper.alignToGrid(this.toBBoxSidePos.x + direction * CanvasHelper.GRID_SIZE), + y: this.toBBoxSidePos.y + } : { + x: this.toBBoxSidePos.x, + y: CanvasHelper.alignToGrid(this.toBBoxSidePos.y + direction * CanvasHelper.GRID_SIZE) + }; + const useUPath = BBoxHelper.isHorizontal(this.toSide) ? this.fromPos.y > BBoxHelper.getCenterOfBBoxSide(this.toNodeBBox, BBoxHelper.getOppositeSide(this.fromSide)).y === BBoxHelper.direction(this.fromSide) > 0 : this.fromPos.x > BBoxHelper.getCenterOfBBoxSide(this.toNodeBBox, BBoxHelper.getOppositeSide(this.fromSide)).x === BBoxHelper.direction(this.fromSide) > 0; + const connectionSide = useUPath ? this.fromSide : BBoxHelper.getOppositeSide(this.fromSide); + const secondToDetourPoint = BBoxHelper.isHorizontal(this.toSide) ? { + x: firstToDetourPoint.x, + y: BBoxHelper.getCenterOfBBoxSide(this.toNodeBBox, connectionSide).y + } : { + x: BBoxHelper.getCenterOfBBoxSide(this.toNodeBBox, connectionSide).x, + y: firstToDetourPoint.y + }; + const path = useUPath ? this.getUPath(this.fromPos, secondToDetourPoint, this.fromSide, this.fromSide) : this.getZPath(this.fromPos, secondToDetourPoint, this.fromSide, this.fromSide); + pathArray.push(...path.pathArray); + pathArray.push(secondToDetourPoint); + pathArray.push(firstToDetourPoint); + pathArray.push(this.toPos); + center = path.center; + } + } + } else { + pathArray.push( + this.fromPos, + idealCenter, + this.toPos + ); + center = { + x: pathArray[1].x, + y: pathArray[1].y + }; + } + } + const svgPath = this.plugin.settings.getSetting("edgeStyleSquarePathRounded") ? SvgPathHelper.pathArrayToRoundedSvgPath(pathArray, ROUNDED_EDGE_RADIUS) : SvgPathHelper.pathArrayToSvgPath(pathArray); + return { svgPath, center, rotateArrows: false }; + } + getUPath(fromPos, toPos, fromSide, toSide) { + const direction = BBoxHelper.direction(fromSide); + if (BBoxHelper.isHorizontal(fromSide)) { + const xExtremum = direction > 0 ? Math.max(fromPos.x, toPos.x) : Math.min(fromPos.x, toPos.x); + const x = CanvasHelper.alignToGrid(xExtremum + direction * CanvasHelper.GRID_SIZE); + return { + pathArray: [ + fromPos, + { x, y: fromPos.y }, + { x, y: toPos.y }, + toPos + ], + center: { + x, + y: (fromPos.y + toPos.y) / 2 + } + }; + } else { + const yExtremum = direction > 0 ? Math.max(fromPos.y, toPos.y) : Math.min(fromPos.y, toPos.y); + const y = CanvasHelper.alignToGrid(yExtremum + direction * CanvasHelper.GRID_SIZE); + return { + pathArray: [ + fromPos, + { x: fromPos.x, y }, + { x: toPos.x, y }, + toPos + ], + center: { + x: (fromPos.x + toPos.x) / 2, + y + } + }; + } + } + getZPath(fromPos, toPos, fromSide, toSide) { + if (BBoxHelper.isHorizontal(fromSide)) { + const midX = fromPos.x + (toPos.x - fromPos.x) / 2; + return { + pathArray: [ + fromPos, + { x: midX, y: fromPos.y }, + { x: midX, y: toPos.y }, + toPos + ], + center: { + x: midX, + y: (fromPos.y + toPos.y) / 2 + } + }; + } else { + const midY = fromPos.y + (toPos.y - fromPos.y) / 2; + return { + pathArray: [ + fromPos, + { x: fromPos.x, y: midY }, + { x: toPos.x, y: midY }, + toPos + ], + center: { + x: (fromPos.x + toPos.x) / 2, + y: midY + } + }; + } + } +}; + +// src/utils/text-helper.ts +var TextHelper = class { + static toCamelCase(str) { + return str.replace(/-./g, (x) => x[1].toUpperCase()); + } + static toTitleCase(str) { + return str.toLowerCase().split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" "); + } +}; + +// src/canvas-extensions/advanced-styles/style-config.ts +function styleAttributeValidator(json) { + var _a; + const hasKey = json.key !== void 0; + const hasLabel = json.label !== void 0; + const hasOptions = Array.isArray(json.options); + if (!hasKey) console.error('Style attribute is missing the "key" property'); + if (!hasLabel) console.error('Style attribute is missing the "label" property'); + if (!hasOptions) console.error('Style attribute is missing the "options" property or it is not an array'); + json.key = TextHelper.toCamelCase(json.key); + let optionsValid = true; + let hasDefault = false; + for (const option of json.options) { + const hasIcon = option.icon !== void 0; + const hasLabel2 = option.label !== void 0; + const hasValue = option.value !== void 0; + if (!hasIcon) console.error(`Style attribute option (${(_a = option.value) != null ? _a : option.label}) is missing the "icon" property`); + if (!hasLabel2) console.error(`Style attribute option (${option.value}) is missing the "label" property`); + if (!hasValue) console.error(`Style attribute option (${option.label}) is missing the "value" property`); + if (!hasIcon || !hasLabel2 || !hasValue) optionsValid = false; + if (option.value === null) hasDefault = true; + } + if (!hasDefault) console.error('Style attribute is missing a default option (option with a "value" of null)'); + const isValid = hasKey && hasLabel && hasOptions && optionsValid && hasDefault; + return isValid ? json : null; +} +var BUILTIN_NODE_STYLE_ATTRIBUTES = [ + { + key: "textAlign", + label: "Text Alignment", + nodeTypes: ["text"], + options: [ + { + icon: "align-left", + label: "Left", + value: null + }, + { + icon: "align-center", + label: "Center", + value: "center" + }, + { + icon: "align-right", + label: "Right", + value: "right" + } + ] + }, + { + key: "shape", + label: "Shape", + nodeTypes: ["text"], + options: [ + { + icon: "rectangle-horizontal", + label: "Round Rectangle", + value: null + }, + { + icon: "shape-pill", + label: "Pill", + value: "pill" + }, + { + icon: "diamond", + label: "Diamond", + value: "diamond" + }, + { + icon: "shape-parallelogram", + label: "Parallelogram", + value: "parallelogram" + }, + { + icon: "circle", + label: "Circle", + value: "circle" + }, + { + icon: "shape-predefined-process", + label: "Predefined Process", + value: "predefined-process" + }, + { + icon: "shape-document", + label: "Document", + value: "document" + }, + { + icon: "shape-database", + label: "Database", + value: "database" + } + ] + }, + { + key: "border", + label: "Border", + options: [ + { + icon: "border-solid", + label: "Solid", + value: null + }, + { + icon: "border-dashed", + label: "Dashed", + value: "dashed" + }, + { + icon: "border-dotted", + label: "Dotted", + value: "dotted" + }, + { + icon: "eye-off", + label: "Invisible", + value: "invisible" + } + ] + } +]; +var BUILTIN_EDGE_STYLE_ATTRIBUTES = [ + { + key: "path", + label: "Path Style", + options: [ + { + icon: "path-solid", + label: "Solid", + value: null + }, + { + icon: "path-dotted", + label: "Dotted", + value: "dotted" + }, + { + icon: "path-short-dashed", + label: "Short Dashed", + value: "short-dashed" + }, + { + icon: "path-long-dashed", + label: "Long Dashed", + value: "long-dashed" + } + ] + }, + { + key: "arrow", + label: "Arrow Style", + options: [ + { + icon: "arrow-triangle", + label: "Triangle", + value: null + }, + { + icon: "arrow-triangle-outline", + label: "Triangle Outline", + value: "triangle-outline" + }, + { + icon: "arrow-thin-triangle", + label: "Thin Triangle", + value: "thin-triangle" + }, + { + icon: "arrow-halved-triangle", + label: "Halved Triangle", + value: "halved-triangle" + }, + { + icon: "arrow-diamond", + label: "Diamond", + value: "diamond" + }, + { + icon: "arrow-diamond-outline", + label: "Diamond Outline", + value: "diamond-outline" + }, + { + icon: "arrow-circle", + label: "Circle", + value: "circle" + }, + { + icon: "arrow-circle-outline", + label: "Circle Outline", + value: "circle-outline" + }, + { + icon: "tally-1", + label: "Blunt", + value: "blunt" + } + ] + }, + { + key: "pathfindingMethod", + label: "Pathfinding Method", + options: [ + { + icon: "pathfinding-method-bezier", + label: "Bezier", + value: null + }, + { + icon: "slash", + label: "Direct", + value: "direct" + }, + { + icon: "pathfinding-method-square", + label: "Square", + value: "square" + }, + { + icon: "map", + label: "A*", + value: "a-star" + } + ] + } +]; + +// src/managers/css-styles-config-manager.ts +var import_obsidian3 = require("obsidian"); +var CssStylesConfigManager = class { + constructor(plugin, trigger, validate) { + this.plugin = plugin; + this.validate = validate; + this.cachedConfig = null; + this.configRegex = new RegExp(`\\/\\*\\s*@${trigger}\\s*\\n([\\s\\S]*?)\\*\\/`, "g"); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "css-change", + () => { + this.cachedConfig = null; + } + )); + } + getStyles() { + if (this.cachedConfig) return this.cachedConfig; + this.cachedConfig = []; + const styleSheets = document.styleSheets; + for (let i = 0; i < styleSheets.length; i++) { + const sheet = styleSheets.item(i); + if (!sheet) continue; + const styleSheetConfigs = this.parseStyleConfigsFromCSS(sheet); + for (const config of styleSheetConfigs) { + const validConfig = this.validate(config); + if (!validConfig) continue; + this.cachedConfig.push(validConfig); + } + } + return this.cachedConfig; + } + parseStyleConfigsFromCSS(sheet) { + var _a, _b; + const textContent = (_b = (_a = sheet == null ? void 0 : sheet.ownerNode) == null ? void 0 : _a.textContent) == null ? void 0 : _b.trim(); + if (!textContent) return []; + const configs = []; + const matches = textContent.matchAll(this.configRegex); + for (const match of matches) { + const yamlString = match[1]; + const configYaml = (0, import_obsidian3.parseYaml)(yamlString); + configs.push(configYaml); + } + return configs; + } +}; + +// src/canvas-extensions/advanced-styles/edge-styles.ts +var GET_EDGE_CSS_STYLES_MANAGER = (plugin) => new CssStylesConfigManager(plugin, "advanced-canvas-edge-style", styleAttributeValidator); +var EDGE_PATHFINDING_METHODS = { + "direct": EdgePathfindingDirect, + "square": EdgePathfindingSquare, + "a-star": EdgePathfindingAStar +}; +var MAX_LIVE_UPDATE_SELECTION_SIZE = 5; +var EdgeStylesExtension = class extends CanvasExtension { + isEnabled() { + return "edgesStylingFeatureEnabled"; + } + init() { + this.cssStylesManager = GET_EDGE_CSS_STYLES_MANAGER(this.plugin); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:popup-menu-created", + (canvas) => this.onPopupMenuCreated(canvas) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:edge-changed", + (canvas, edge) => this.onEdgeChanged(canvas, edge) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:edge-center-requested", + (canvas, edge, center) => this.onEdgeCenterRequested(canvas, edge, center) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-added", + (canvas, node) => { + if (canvas.dirty.size > 1 && !canvas.isPasting) return; + this.updateAllEdgesInArea(canvas, node.getBBox()); + } + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-moved", + // Only update edges this way if a node got moved with the arrow keys + (canvas, node, keyboard) => node.initialized && keyboard ? this.updateAllEdgesInArea(canvas, node.getBBox()) : void 0 + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-removed", + (canvas, node) => this.updateAllEdgesInArea(canvas, node.getBBox()) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:dragging-state-changed", + (canvas, isDragging) => { + if (isDragging) return; + const selectedNodes = canvas.getSelectionData().nodes.map((nodeData) => canvas.nodes.get(nodeData.id)).filter((node) => node !== void 0); + const selectedNodeBBoxes = selectedNodes.map((node) => node.getBBox()); + const selectedNodeBBox = BBoxHelper.combineBBoxes(selectedNodeBBoxes); + this.updateAllEdgesInArea(canvas, selectedNodeBBox); + } + )); + } + // Skip if isDragging and setting isn't enabled and not connecting an edge + shouldUpdateEdge(canvas) { + return !canvas.isDragging || this.plugin.settings.getSetting("edgeStyleUpdateWhileDragging") || canvas.canvasEl.hasClass("is-connecting"); + } + onPopupMenuCreated(canvas) { + var _a; + const selectedEdges = [...canvas.selection].filter((item) => item.path !== void 0); + if (canvas.readonly || selectedEdges.length === 0 || selectedEdges.length !== canvas.selection.size) + return; + CanvasHelper.addStyleAttributesToPopup( + this.plugin, + canvas, + [ + ...BUILTIN_EDGE_STYLE_ATTRIBUTES, + /* Legacy */ + ...this.plugin.settings.getSetting("customEdgeStyleAttributes"), + ...this.cssStylesManager.getStyles() + ], + (_a = selectedEdges[0].getData().styleAttributes) != null ? _a : {}, + (attribute, value) => this.setStyleAttributeForSelection(canvas, attribute, value) + ); + } + setStyleAttributeForSelection(canvas, attribute, value) { + const selectedEdges = [...canvas.selection].filter((item) => item.path !== void 0); + for (const edge of selectedEdges) { + const edgeData = edge.getData(); + edge.setData({ + ...edgeData, + styleAttributes: { + ...edgeData.styleAttributes, + [attribute.key]: value + } + }); + } + canvas.pushHistory(canvas.getData()); + } + updateAllEdgesInArea(canvas, bbox) { + if (!this.shouldUpdateEdge(canvas)) return; + for (const edge of canvas.edges.values()) { + if (!BBoxHelper.isColliding(edge.getBBox(), bbox)) continue; + canvas.markDirty(edge); + } + } + onEdgeChanged(canvas, edge) { + var _a, _b, _c, _d, _e, _f, _g; + if (!canvas.dirty.has(edge) && !canvas.selection.has(edge)) return; + if (!this.shouldUpdateEdge(canvas)) { + const tooManySelected = canvas.selection.size > MAX_LIVE_UPDATE_SELECTION_SIZE; + if (tooManySelected) return; + const groupNodesSelected = [...canvas.selection].some((item) => { + var _a2; + return ((_a2 = item.getData()) == null ? void 0 : _a2.type) === "group"; + }); + if (groupNodesSelected) return; + } + const edgeData = edge.getData(); + if (!edge.bezier) return; + edge.center = void 0; + edge.updatePath(); + const pathfindingMethod = (_a = edgeData.styleAttributes) == null ? void 0 : _a.pathfindingMethod; + if (pathfindingMethod && pathfindingMethod in EDGE_PATHFINDING_METHODS) { + const fromNodeBBox = edge.from.node.getBBox(); + const fromBBoxSidePos = BBoxHelper.getCenterOfBBoxSide(fromNodeBBox, edge.from.side); + const fromPos = edge.from.end === "none" ? fromBBoxSidePos : edge.bezier.from; + const toNodeBBox = edge.to.node.getBBox(); + const toBBoxSidePos = BBoxHelper.getCenterOfBBoxSide(toNodeBBox, edge.to.side); + const toPos = edge.to.end === "none" ? toBBoxSidePos : edge.bezier.to; + const path = new EDGE_PATHFINDING_METHODS[pathfindingMethod]( + this.plugin, + canvas, + fromNodeBBox, + fromPos, + fromBBoxSidePos, + edge.from.side, + toNodeBBox, + toPos, + toBBoxSidePos, + edge.to.side + ).getPath(); + if (!path) return; + edge.center = path.center; + edge.path.interaction.setAttr("d", path == null ? void 0 : path.svgPath); + edge.path.display.setAttr("d", path == null ? void 0 : path.svgPath); + } + (_b = edge.labelElement) == null ? void 0 : _b.render(); + const arrowPolygonPoints = this.getArrowPolygonPoints((_c = edgeData.styleAttributes) == null ? void 0 : _c.arrow); + if ((_d = edge.fromLineEnd) == null ? void 0 : _d.el) (_e = edge.fromLineEnd.el.querySelector("polygon")) == null ? void 0 : _e.setAttribute("points", arrowPolygonPoints); + if ((_f = edge.toLineEnd) == null ? void 0 : _f.el) (_g = edge.toLineEnd.el.querySelector("polygon")) == null ? void 0 : _g.setAttribute("points", arrowPolygonPoints); + } + onEdgeCenterRequested(_canvas, edge, center) { + var _a, _b, _c, _d; + center.x = (_b = (_a = edge.center) == null ? void 0 : _a.x) != null ? _b : center.x; + center.y = (_d = (_c = edge.center) == null ? void 0 : _c.y) != null ? _d : center.y; + } + getArrowPolygonPoints(arrowStyle) { + if (arrowStyle === "halved-triangle") + return `-2,0 7.5,12 -2,12`; + else if (arrowStyle === "thin-triangle") + return `0,0 7,10 0,0 0,10 0,0 -7,10`; + else if (arrowStyle === "diamond" || arrowStyle === "diamond-outline") + return `0,0 5,10 0,20 -5,10`; + else if (arrowStyle === "circle" || arrowStyle === "circle-outline") + return `0 0, 4.95 1.8, 7.5 6.45, 6.6 11.7, 2.7 15, -2.7 15, -6.6 11.7, -7.5 6.45, -4.95 1.8`; + else if (arrowStyle === "blunt") + return `-10,8 10,8 10,6 -10,6`; + else + return `0,0 6.5,10.4 -6.5,10.4`; + } +}; + +// src/canvas-extensions/advanced-styles/node-styles.ts +var GET_NODE_CSS_STYLES_MANAGER = (plugin) => new CssStylesConfigManager(plugin, "advanced-canvas-node-style", styleAttributeValidator); +var NodeStylesExtension = class extends CanvasExtension { + isEnabled() { + return "nodeStylingFeatureEnabled"; + } + init() { + this.cssStylesManager = GET_NODE_CSS_STYLES_MANAGER(this.plugin); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:popup-menu-created", + (canvas) => this.onPopupMenuCreated(canvas) + )); + } + onPopupMenuCreated(canvas) { + var _a; + const selectionNodeData = canvas.getSelectionData().nodes; + if (canvas.readonly || selectionNodeData.length === 0 || selectionNodeData.length !== canvas.selection.size) + return; + const selectedNodeTypes = new Set(selectionNodeData.map((node) => node.type)); + const availableNodeStyles = [ + ...BUILTIN_NODE_STYLE_ATTRIBUTES, + /* Legacy */ + ...this.plugin.settings.getSetting("customNodeStyleAttributes"), + ...this.cssStylesManager.getStyles() + ].filter((style) => !style.nodeTypes || style.nodeTypes.some((type) => selectedNodeTypes.has(type))); + CanvasHelper.addStyleAttributesToPopup( + this.plugin, + canvas, + availableNodeStyles, + (_a = selectionNodeData[0].styleAttributes) != null ? _a : {}, + (attribute, value) => this.setStyleAttributeForSelection(canvas, attribute, value) + ); + } + setStyleAttributeForSelection(canvas, attribute, value) { + const selectionNodeData = canvas.getSelectionData().nodes; + for (const nodeData of selectionNodeData) { + const node = canvas.nodes.get(nodeData.id); + if (!node) continue; + if (attribute.nodeTypes && !attribute.nodeTypes.includes(nodeData.type)) continue; + node.setData({ + ...nodeData, + styleAttributes: { + ...nodeData.styleAttributes, + [attribute.key]: value + } + }); + } + canvas.pushHistory(canvas.getData()); + } +}; + +// src/canvas-extensions/variable-breakpoint-canvas-extension.ts +var VARIABLE_BREAKPOINT_CSS_VAR = "--variable-breakpoint"; +var VariableBreakpointCanvasExtension = class extends CanvasExtension { + isEnabled() { + return "variableBreakpointFeatureEnabled"; + } + init() { + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-breakpoint-changed", + (canvas, node, breakpointRef) => this.onNodeBreakpointChanged(canvas, node, breakpointRef) + )); + } + onNodeBreakpointChanged(canvas, node, breakpointRef) { + if (!node.initialized) return; + if (node.breakpoint === void 0) { + const computedStyle = window.getComputedStyle(node.nodeEl); + const variableBreakpointString = computedStyle.getPropertyValue(VARIABLE_BREAKPOINT_CSS_VAR); + let numberBreakpoint; + if (variableBreakpointString.length > 0 && !isNaN(numberBreakpoint = parseFloat(variableBreakpointString))) + node.breakpoint = numberBreakpoint; + else node.breakpoint = null; + } + if (node.breakpoint === null) return; + breakpointRef.value = canvas.zoom > node.breakpoint; + } +}; + +// src/settings.ts +var README_URL = "https://github.com/Developer-Mike/obsidian-advanced-canvas?tab=readme-ov-file"; +var SPENT_HOURS = 250; +var RECEIVED_DONATIONS = 606; +var HOURLY_RATE_GOAL = 15; +var KOFI_PAGE_URL = "https://ko-fi.com/X8X27IA08"; +var KOFI_BADGE_URI = "data:image/webp;base64,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"; +var DEFAULT_SETTINGS_VALUES = { + nodeTypeOnDoubleClick: "text", + alignNewNodesToGrid: true, + defaultTextNodeDimensions: [260, 60], + defaultFileNodeDimensions: [400, 400], + minNodeSize: 60, + maxNodeWidth: -1, + disableFontSizeRelativeToZoom: false, + canvasMetadataCompatibilityEnabled: true, + enableSingleNodeLinks: true, + combineCustomStylesInDropdown: false, + nodeStylingFeatureEnabled: true, + customNodeStyleAttributes: [], + defaultTextNodeColor: 0, + defaultTextNodeStyleAttributes: {}, + edgesStylingFeatureEnabled: true, + customEdgeStyleAttributes: [], + inheritEdgeColorFromNode: false, + defaultEdgeColor: 0, + defaultEdgeLineDirection: "unidirectional", + defaultEdgeStyleAttributes: {}, + edgeStyleUpdateWhileDragging: false, + edgeStyleSquarePathRounded: true, + edgeStylePathfinderAllowDiagonal: false, + edgeStylePathfinderPathRounded: true, + variableBreakpointFeatureEnabled: false, + zOrderingControlFeatureEnabled: false, + zOrderingControlShowOneLayerShiftOptions: false, + aspectRatioControlFeatureEnabled: false, + commandsFeatureEnabled: true, + zoomToClonedNode: true, + cloneNodeMargin: 20, + expandNodeStepSize: 20, + nativeFileSearchEnabled: true, + floatingEdgeFeatureEnabled: true, + allowFloatingEdgeCreation: false, + newEdgeFromSideFloating: false, + flipEdgeFeatureEnabled: true, + betterExportFeatureEnabled: true, + betterReadonlyEnabled: false, + hideBackgroundGridWhenInReadonly: true, + disableNodePopup: false, + disableZoom: false, + disablePan: false, + autoResizeNodeFeatureEnabled: false, + autoResizeNodeEnabledByDefault: false, + autoResizeNodeMaxHeight: -1, + autoResizeNodeSnapToGrid: true, + collapsibleGroupsFeatureEnabled: true, + collapsedGroupPreviewOnDrag: true, + focusModeFeatureEnabled: false, + presentationFeatureEnabled: true, + showSetStartNodeInPopup: false, + defaultSlideDimensions: [1200, 675], + wrapInSlidePadding: 20, + resetViewportOnPresentationEnd: true, + useArrowKeysToChangeSlides: true, + usePgUpPgDownKeysToChangeSlides: true, + zoomToSlideWithoutPadding: true, + useUnclampedZoomWhilePresenting: false, + fullscreenPresentationEnabled: true, + slideTransitionAnimationDuration: 0.5, + slideTransitionAnimationIntensity: 1.25, + canvasEncapsulationEnabled: false, + portalsFeatureEnabled: true, + showEdgesIntoDisabledPortals: true, + autoFileNodeEdgesFeatureEnabled: false, + autoFileNodeEdgesFrontmatterKey: "canvas-edges", + edgeHighlightEnabled: false, + highlightIncomingEdges: false, + edgeSelectionEnabled: false, + selectEdgeByDirection: false +}; +var SETTINGS = { + general: { + label: "General", + description: "General settings of the Advanced Canvas plugin.", + disableToggle: true, + children: { + nodeTypeOnDoubleClick: { + label: "Node type on double click", + description: "The type of node that will be created when double clicking on the canvas.", + type: "dropdown", + options: { + "text": "Text", + "file": "File" + } + }, + alignNewNodesToGrid: { + label: "Always align new nodes to grid", + description: "When enabled, new nodes will be aligned to the grid.", + type: "boolean" + }, + defaultTextNodeDimensions: { + label: "Default text node dimensions", + description: "The default dimensions of a text node.", + type: "dimension", + parse: (value) => { + const width = Math.max(1, parseInt(value[0]) || 0); + const height = Math.max(1, parseInt(value[1]) || 0); + return [width, height]; + } + }, + defaultFileNodeDimensions: { + label: "Default file node dimensions", + description: "The default dimensions of a file node.", + type: "dimension", + parse: (value) => { + const width = Math.max(1, parseInt(value[0]) || 0); + const height = Math.max(1, parseInt(value[1]) || 0); + return [width, height]; + } + }, + minNodeSize: { + label: "Minimum node size", + description: "The minimum size (either width or height) of a node.", + type: "number", + parse: (value) => Math.max(1, parseInt(value) || 0) + }, + maxNodeWidth: { + label: "Maximum node width", + description: "The maximum width of a node. Set to -1 for no limit.", + type: "number", + parse: (value) => Math.max(-1, parseInt(value) || 0) + }, + disableFontSizeRelativeToZoom: { + label: "Disable font size relative to zoom", + description: "When enabled, the font size of e.g. group node titles and edge labels will not increase when zooming out.", + type: "boolean" + } + } + }, + commandsFeatureEnabled: { + label: "Extended commands", + description: "Add more commands to the canvas.", + infoSection: "canvas-commands", + children: { + zoomToClonedNode: { + label: "Zoom to cloned node", + description: "When enabled, the canvas will zoom to the cloned node.", + type: "boolean" + }, + cloneNodeMargin: { + label: "Clone node margin", + description: "The margin between the cloned node and the source node.", + type: "number", + parse: (value) => Math.max(0, parseInt(value) || 0) + }, + expandNodeStepSize: { + label: "Expand node step size", + description: "The step size for expanding the node.", + type: "number", + parse: (value) => Math.max(1, parseInt(value) || 0) + } + } + }, + canvasMetadataCompatibilityEnabled: { + label: "Enable .canvas metadata cache compatibility", + description: "Make .canvas files compatible with the backlinks and outgoing links feature and show the connections in the graph view.", + infoSection: "full-metadata-cache-support", + children: { + enableSingleNodeLinks: { + label: "Enable support for linking to a node using a [[wikilink]]", + description: "When enabled, you can link and embed a node using [[canvas-file#node-id]].", + type: "boolean" + } + } + }, + nativeFileSearchEnabled: { + label: "Native-like file search", + description: "When enabled, the file search will be done using the native Obsidian file search.", + infoSection: "native-like-file-search", + children: {} + }, + autoFileNodeEdgesFeatureEnabled: { + label: "Auto file node edges", + description: "Automatically create edges between file nodes based their frontmatter links.", + infoSection: "auto-file-node-edges", + children: { + autoFileNodeEdgesFrontmatterKey: { + label: "Frontmatter key name", + description: "The frontmatter key to fetch the outgoing edges from. (Keep the default to ensure best compatibility.)", + type: "text", + parse: (value) => value.trim() || "canvas-edges" + } + } + }, + portalsFeatureEnabled: { + label: "Portals", + description: "Create portals to other canvases.", + infoSection: "portals", + children: { + showEdgesIntoDisabledPortals: { + label: "Show edges into disabled portals", + description: "When enabled, edges into disabled portals will be shown.", + type: "boolean" + } + } + }, + collapsibleGroupsFeatureEnabled: { + label: "Collapsible groups", + description: "Group nodes can be collapsed and expanded to keep the canvas organized.", + infoSection: "collapsible-groups", + children: { + collapsedGroupPreviewOnDrag: { + label: "Collapsed group preview on drag", + description: "When enabled, a group that is collapsed show its border while dragging a node.", + type: "boolean" + } + } + }, + combineCustomStylesInDropdown: { + label: "Combine custom styles", + description: "Combine all style attributes of Advanced Canvas in a single dropdown.", + children: {} + }, + nodeStylingFeatureEnabled: { + label: "Node styling", + description: "Style your nodes with different shapes and borders.", + infoSection: "node-styles", + children: { + customNodeStyleAttributes: { + label: "Custom node style settings", + description: "Add custom style settings for nodes. (Go to GitHub for more information)", + type: "button", + onClick: () => window.open("https://github.com/Developer-Mike/obsidian-advanced-canvas/blob/main/README.md#custom-styles") + }, + defaultTextNodeColor: { + label: "Default text node color", + description: "The default color of a text node. The default range is from 0 to 6, where 0 is no color. The range can be extended by using the Custom Colors feature of Advanced Canvas.", + type: "number", + parse: (value) => Math.max(0, parseInt(value) || 0) + }, + defaultTextNodeStyleAttributes: { + label: "Default text node style attributes", + type: "styles", + getParameters(settingsManager) { + return [ + ...BUILTIN_NODE_STYLE_ATTRIBUTES, + /* BUILTINS */ + ...settingsManager.nodeCssStylesManager.getStyles(), + /* CUSTOM CSS STYLES */ + ...settingsManager.getSetting("customNodeStyleAttributes") + /* LEGACY CUSTOM STYLES */ + ].filter((setting) => { + var _a; + return setting.nodeTypes === void 0 || ((_a = setting.nodeTypes) == null ? void 0 : _a.includes("text")); + }); + } + } + } + }, + edgesStylingFeatureEnabled: { + label: "Edges styling", + description: "Style your edges with different path styles.", + infoSection: "edge-styles", + children: { + customEdgeStyleAttributes: { + label: "Custom edge style settings", + description: "Add custom style settings for edges. (Go to GitHub for more information)", + type: "button", + onClick: () => window.open("https://github.com/Developer-Mike/obsidian-advanced-canvas/blob/main/README.md#custom-styles") + }, + inheritEdgeColorFromNode: { + label: "Inherit edge color from node", + description: "When creating a new edge by dragging from a node, the edge will inherit the color of the node it is dragged from.", + type: "boolean" + }, + defaultEdgeColor: { + label: "Default edge color", + description: "The default color of an edge. The default range is from 0 to 6, where 0 is no color. The range can be extended by using the Custom Colors feature of Advanced Canvas.", + type: "number", + parse: (value) => Math.max(0, parseInt(value) || 0) + }, + defaultEdgeLineDirection: { + label: "Default edge line direction", + description: "The default line direction of an edge.", + type: "dropdown", + options: { + "nondirectional": "Nondirectional", + "unidirectional": "Unidirectional", + "bidirectional": "Bidirectional" + } + }, + defaultEdgeStyleAttributes: { + label: "Default edge style attributes", + type: "styles", + getParameters(settingsManager) { + return [ + ...BUILTIN_EDGE_STYLE_ATTRIBUTES, + /* BUILTINS */ + ...settingsManager.edgeCssStylesManager.getStyles(), + /* CUSTOM CSS STYLES */ + ...settingsManager.getSetting("customEdgeStyleAttributes") + /* LEGACY CUSTOM STYLES */ + ]; + } + }, + edgeStyleUpdateWhileDragging: { + label: "Update edge style while dragging (Can be very slow)", + description: "When enabled, the edge style will be updated while dragging an edge.", + type: "boolean" + }, + edgeStyleSquarePathRounded: { + label: "Square path rounded", + description: "When enabled, the square path's corners will be rounded.", + type: "boolean" + }, + edgeStylePathfinderAllowDiagonal: { + label: "A* allow diagonal", + description: "When enabled, the A* path style will allow diagonal paths.", + type: "boolean" + }, + edgeStylePathfinderPathRounded: { + label: "A* rounded path", + description: "When enabled, the A* path style will be rounded.", + type: "boolean" + } + } + }, + floatingEdgeFeatureEnabled: { + label: "Floating edges (auto edge side)", + description: "Floating edges are automatically placed on the most suitable side of the node.", + infoSection: "floating-edges-automatic-edge-side", + children: { + allowFloatingEdgeCreation: { + label: "Allow floating edges creation", + description: "Allow floating edges creation by dragging the edge over the target node without placing it over a specific side connection point. (If disabled, floating edges can only be created and used by other Advanced Canvas features.)", + type: "boolean" + }, + newEdgeFromSideFloating: { + label: "New edge from side floating", + description: 'When enabled, the "from" side of the edge will always be floating.', + type: "boolean" + } + } + }, + flipEdgeFeatureEnabled: { + label: "Flip edges", + description: "Flip the direction of edges using the popup menu.", + infoSection: "flip-edge", + children: {} + }, + presentationFeatureEnabled: { + label: "Presentations", + description: "Create a presentation from your canvas.", + infoSection: "presentation-mode", + children: { + showSetStartNodeInPopup: { + label: 'Show "Set Start Node" in node popup', + description: "If turned off, you can still set the start node using the corresponding command.", + type: "boolean" + }, + defaultSlideDimensions: { + label: "Default slide dimensions", + description: "The default dimensions of a slide.", + type: "dimension", + parse: (value) => { + const width = Math.max(1, parseInt(value[0]) || 0); + const height = Math.max(1, parseInt(value[1]) || 0); + return [width, height]; + } + }, + wrapInSlidePadding: { + label: "Wrap in slide padding", + description: "The padding of the slide when wrapping the canvas in a slide.", + type: "number", + parse: (value) => Math.max(0, parseInt(value) || 0) + }, + resetViewportOnPresentationEnd: { + label: "Reset viewport on presentation end", + description: "When enabled, the viewport will be reset to the original position after the presentation ends.", + type: "boolean" + }, + useArrowKeysToChangeSlides: { + label: "Use arrow keys to change slides", + description: "When enabled, you can use the arrow keys to change slides in presentation mode.", + type: "boolean" + }, + usePgUpPgDownKeysToChangeSlides: { + label: "Use PgUp/PgDown keys to change slides", + description: "When enabled, you can use the PgUp/PgDown keys to change slides in presentation mode (Makes the presentation mode compatible with most presentation remotes).", + type: "boolean" + }, + zoomToSlideWithoutPadding: { + label: "Zoom to slide without padding", + description: "When enabled, the canvas will zoom to the slide without padding.", + type: "boolean" + }, + useUnclampedZoomWhilePresenting: { + label: "Use unclamped zoom while presenting", + description: "When enabled, the zoom will not be clamped while presenting.", + type: "boolean" + }, + fullscreenPresentationEnabled: { + label: "Enter fullscreen while presenting", + description: "When enabled, presentations automatically request fullscreen. Disable to keep Obsidian windowed during presentations.", + type: "boolean" + }, + slideTransitionAnimationDuration: { + label: "Slide transition animation duration", + description: "The duration of the slide transition animation in seconds. Set to 0 to disable the animation.", + type: "number", + parse: (value) => Math.max(0, parseFloat(value) || 0) + }, + slideTransitionAnimationIntensity: { + label: "Slide transition animation intensity", + description: "The intensity of the slide transition animation. The higher the value, the more the canvas will zoom out before zooming in on the next slide.", + type: "number", + parse: (value) => Math.max(0, parseFloat(value) || 0) + } + } + }, + zOrderingControlFeatureEnabled: { + label: "Z ordering controls", + description: "Change the persistent z-index of nodes using the context menu.", + children: { + zOrderingControlShowOneLayerShiftOptions: { + label: "Show one layer shift options", + description: "When enabled, you can move nodes one layer forward or backward.", + type: "boolean" + } + } + }, + aspectRatioControlFeatureEnabled: { + label: "Aspect ratio control", + description: "Change the aspect ratio of nodes using the context menu.", + children: {} + }, + variableBreakpointFeatureEnabled: { + label: "Variable breakpoint", + description: `Change the zoom breakpoint (the zoom level at which the nodes won't render their content anymore) on a per-node basis using the ${VARIABLE_BREAKPOINT_CSS_VAR} CSS variable.`, + infoSection: "variable-breakpoints", + children: {} + }, + autoResizeNodeFeatureEnabled: { + label: "Auto resize node", + description: "Automatically resize the height of a node to fit the content.", + infoSection: "auto-node-resizing", + children: { + autoResizeNodeEnabledByDefault: { + label: "Enable auto resize by default", + description: "When enabled, the auto resize feature will be enabled by default for all nodes.", + type: "boolean" + }, + autoResizeNodeMaxHeight: { + label: "Max height", + description: "The maximum height of the node when auto resizing (-1 for unlimited).", + type: "number", + parse: (value) => { + var _a; + return Math.max(-1, (_a = parseInt(value)) != null ? _a : -1); + } + }, + autoResizeNodeSnapToGrid: { + label: "Snap to grid", + description: "When enabled, the height of the node will snap to the grid.", + type: "boolean" + } + } + }, + canvasEncapsulationEnabled: { + label: "Canvas encapsulation", + description: "Encapsulate a selection of nodes and edges into a new canvas using the context menu.", + infoSection: "encapsulate-selection", + children: {} + }, + betterReadonlyEnabled: { + label: "Better readonly", + description: "Improve the readonly mode.", + infoSection: "better-readonly", + children: { + hideBackgroundGridWhenInReadonly: { + label: "Hide background grid when in readonly", + description: "When enabled, the background grid will be hidden when in readonly mode.", + type: "boolean" + } + } + }, + edgeHighlightEnabled: { + label: "Edge highlight", + description: "Highlight outgoing (and optionally incoming) edges of a selected node.", + infoSection: "edge-highlight", + children: { + highlightIncomingEdges: { + label: "Highlight incoming edges", + description: "When enabled, incoming edges will also be highlighted.", + type: "boolean" + } + } + }, + edgeSelectionEnabled: { + label: "Edge selection", + description: "Select edges connected to the selected node(s) using the popup menu.", + infoSection: "edge-selection", + children: { + selectEdgeByDirection: { + label: "Select edge by direction", + description: "Select incoming or outgoing edges using separate popup menu items.", + type: "boolean" + } + } + }, + focusModeFeatureEnabled: { + label: "Focus mode", + description: "Focus on a single node and blur all other nodes.", + infoSection: "focus-mode", + children: {} + } +}; +var SettingsManager = class { + constructor(plugin) { + this.plugin = plugin; + this.nodeCssStylesManager = GET_NODE_CSS_STYLES_MANAGER(plugin); + this.edgeCssStylesManager = GET_EDGE_CSS_STYLES_MANAGER(plugin); + } + async loadSettings() { + this.settings = Object.assign({}, DEFAULT_SETTINGS_VALUES, await this.plugin.loadData()); + this.plugin.app.workspace.trigger("advanced-canvas:settings-changed"); + } + async saveSettings() { + await this.plugin.saveData(this.settings); + } + getSetting(key) { + return this.settings[key]; + } + async setSetting(data) { + this.settings = Object.assign(this.settings, data); + await this.saveSettings(); + this.plugin.app.workspace.trigger("advanced-canvas:settings-changed"); + } + addSettingsTab() { + this.settingsTab = new AdvancedCanvasPluginSettingTab(this.plugin, this); + this.plugin.addSettingTab(this.settingsTab); + } +}; +var AdvancedCanvasPluginSettingTab = class extends import_obsidian4.PluginSettingTab { + constructor(plugin, settingsManager) { + super(plugin.app, plugin); + this.settingsManager = settingsManager; + } + display() { + const { containerEl } = this; + containerEl.empty(); + this.createKofiBanner(containerEl); + for (const [headingId, heading] of Object.entries(SETTINGS)) { + this.createFeatureHeading( + containerEl, + heading.label, + heading.description, + heading.infoSection, + heading.disableToggle ? null : headingId + ); + const settingsHeaderChildrenContainerEl = document.createElement("div"); + settingsHeaderChildrenContainerEl.classList.add("settings-header-children"); + settingsHeaderChildrenContainerEl.appendChild(document.createElement("span")); + containerEl.appendChild(settingsHeaderChildrenContainerEl); + for (const [settingId, setting] of Object.entries(heading.children)) { + if (!(settingId in DEFAULT_SETTINGS_VALUES)) continue; + switch (setting.type) { + case "text": + this.createTextSetting(settingsHeaderChildrenContainerEl, settingId, setting); + break; + case "number": + this.createNumberSetting(settingsHeaderChildrenContainerEl, settingId, setting); + break; + case "dimension": + this.createDimensionSetting(settingsHeaderChildrenContainerEl, settingId, setting); + break; + case "boolean": + this.createBooleanSetting(settingsHeaderChildrenContainerEl, settingId, setting); + break; + case "dropdown": + this.createDropdownSetting(settingsHeaderChildrenContainerEl, settingId, setting); + break; + case "button": + this.createButtonSetting(settingsHeaderChildrenContainerEl, settingId, setting); + break; + case "styles": + this.createStylesSetting(settingsHeaderChildrenContainerEl, settingId, setting); + break; + } + } + } + } + createFeatureHeading(containerEl, label, description, infoSection, settingsKey) { + const setting = new import_obsidian4.Setting(containerEl).setHeading().setClass("ac-settings-heading").setName(label).setDesc(description); + if (infoSection !== void 0) { + setting.addExtraButton( + (button) => button.setTooltip("Open github documentation").setIcon("info").onClick(async () => { + window.open(`${README_URL}#${infoSection}`); + }) + ); + } + if (settingsKey !== null) { + setting.addToggle( + (toggle) => toggle.setTooltip("Requires a reload to take effect.").setValue(this.settingsManager.getSetting(settingsKey)).onChange(async (value) => { + await this.settingsManager.setSetting({ [settingsKey]: value }); + new import_obsidian4.Notice("Reload obsidian to apply the changes."); + }) + ); + } + return setting; + } + createTextSetting(containerEl, settingId, setting) { + new import_obsidian4.Setting(containerEl).setName(setting.label).setDesc(setting.description).addText( + (text) => text.setValue(this.settingsManager.getSetting(settingId)).onChange(async (value) => { + await this.settingsManager.setSetting({ [settingId]: setting.parse ? setting.parse(value) : value }); + }) + ); + } + createNumberSetting(containerEl, settingId, setting) { + new import_obsidian4.Setting(containerEl).setName(setting.label).setDesc(setting.description).addText( + (text) => text.setValue(this.settingsManager.getSetting(settingId).toString()).onChange(async (value) => { + await this.settingsManager.setSetting({ [settingId]: setting.parse(value) }); + }) + ); + } + createDimensionSetting(containerEl, settingId, setting) { + let text1; + let text2; + new import_obsidian4.Setting(containerEl).setName(setting.label).setDesc(setting.description).addText((text) => { + text1 = text.setValue(this.settingsManager.getSetting(settingId)[0].toString()).onChange(async (value) => await this.settingsManager.setSetting({ [settingId]: setting.parse([value, text2.getValue()]) })); + }).addText((text) => { + text2 = text.setValue(this.settingsManager.getSetting(settingId)[1].toString()).onChange(async (value) => await this.settingsManager.setSetting({ [settingId]: setting.parse([text1.getValue(), value]) })); + }); + } + createBooleanSetting(containerEl, settingId, setting) { + new import_obsidian4.Setting(containerEl).setName(setting.label).setDesc(setting.description).addToggle( + (toggle) => toggle.setValue(this.settingsManager.getSetting(settingId)).onChange(async (value) => { + await this.settingsManager.setSetting({ [settingId]: value }); + }) + ); + } + createDropdownSetting(containerEl, settingId, setting) { + new import_obsidian4.Setting(containerEl).setName(setting.label).setDesc(setting.description).addDropdown( + (dropdown) => dropdown.addOptions(setting.options).setValue(this.settingsManager.getSetting(settingId)).onChange(async (value) => { + await this.settingsManager.setSetting({ [settingId]: value }); + }) + ); + } + createButtonSetting(containerEl, settingId, setting) { + new import_obsidian4.Setting(containerEl).setName(setting.label).setDesc(setting.description).addButton( + (button) => button.setButtonText("Open").onClick(() => setting.onClick()) + ); + } + createStylesSetting(containerEl, settingId, setting) { + const nestedContainerEl = document.createElement("details"); + nestedContainerEl.classList.add("setting-item"); + containerEl.appendChild(nestedContainerEl); + const summaryEl = document.createElement("summary"); + summaryEl.textContent = setting.label; + nestedContainerEl.appendChild(summaryEl); + for (const styleAttribute of setting.getParameters(this.settingsManager)) { + new import_obsidian4.Setting(nestedContainerEl).setName(styleAttribute.label).addDropdown( + (dropdown) => { + var _a; + return dropdown.addOptions(Object.fromEntries(styleAttribute.options.map((option) => [option.value, option.value === null ? `${option.label} (default)` : option.label]))).setValue((_a = this.settingsManager.getSetting(settingId)[styleAttribute.key]) != null ? _a : "null").onChange(async (value) => { + const newValue = this.settingsManager.getSetting(settingId); + if (value === "null") delete newValue[styleAttribute.key]; + else newValue[styleAttribute.key] = value; + await this.settingsManager.setSetting({ + [settingId]: newValue + }); + }); + } + ); + } + } + async createKofiBanner(containerEl) { + const banner = document.createElement("div"); + banner.classList.add("kofi-banner"); + const title = document.createElement("h1"); + title.textContent = "Enjoying the plugin?"; + banner.appendChild(title); + const description = document.createElement("p"); + description.innerHTML = ` + Currently, Advanced Canvas has received about ${RECEIVED_DONATIONS}\xA3 in donations with a total of about ${SPENT_HOURS} hours spent on development.
+
+ Please help me develop this plugin further by reaching the goal of ${HOURLY_RATE_GOAL}\xA3/hour \u2764\uFE0F + `; + banner.appendChild(description); + const progressContainer = document.createElement("div"); + progressContainer.classList.add("progress-container"); + const progressbar = document.createElement("progress"); + progressbar.value = RECEIVED_DONATIONS / SPENT_HOURS; + progressbar.max = HOURLY_RATE_GOAL; + progressContainer.appendChild(progressbar); + const hourlyRate = document.createElement("span"); + hourlyRate.classList.add("hourly-rate"); + hourlyRate.textContent = `${(RECEIVED_DONATIONS / SPENT_HOURS).toString()}\xA3/h`; + progressContainer.appendChild(hourlyRate); + banner.appendChild(progressContainer); + const koFiButton = document.createElement("a"); + koFiButton.classList.add("ac-kofi-button"); + koFiButton.href = KOFI_PAGE_URL; + koFiButton.target = "_blank"; + const koFiImage = document.createElement("img"); + koFiImage.src = KOFI_BADGE_URI; + koFiButton.appendChild(koFiImage); + banner.appendChild(koFiButton); + containerEl.appendChild(banner); + } +}; + +// src/managers/windows-manager.ts +var WindowsManager = class { + constructor(plugin) { + this.windows = [window]; + this.plugin = plugin; + this.plugin.registerEvent(this.plugin.app.workspace.on( + "window-open", + (_win, window2) => this.windows.push(window2) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "window-close", + (_win, window2) => this.windows = this.windows.filter((w) => w !== window2) + )); + } +}; + +// src/patchers/canvas-patcher.ts +var import_view = require("@codemirror/view"); + +// node_modules/monkey-around/mjs/index.js +function around(obj, factories) { + const removers = Object.keys(factories).map((key) => around1(obj, key, factories[key])); + return removers.length === 1 ? removers[0] : function() { + removers.forEach((r) => r()); + }; +} +function around1(obj, method, createWrapper) { + const original = obj[method], hadOwn = obj.hasOwnProperty(method); + let current = createWrapper(original); + if (original) + Object.setPrototypeOf(current, original); + Object.setPrototypeOf(wrapper, current); + obj[method] = wrapper; + return remove; + function wrapper(...args) { + if (current === original && obj[method] === wrapper) + remove(); + return current.apply(this, args); + } + function remove() { + if (obj[method] === wrapper) { + if (hadOwn) + obj[method] = original; + else + delete obj[method]; + } + if (current === original) + return; + current = original; + Object.setPrototypeOf(wrapper, original || Function); + } +} + +// src/patchers/canvas-patcher.ts +var import_obsidian5 = require("obsidian"); + +// node_modules/tiny-jsonc/dist/index.js +var stringOrCommentRe = /("(?:\\?[^])*?")|(\/\/.*)|(\/\*[^]*?\*\/)/g; +var stringOrTrailingCommaRe = /("(?:\\?[^])*?")|(,\s*)(?=]|})/g; +var JSONC = { + parse: (text) => { + text = String(text); + try { + return JSON.parse(text); + } catch (e) { + return JSON.parse(text.replace(stringOrCommentRe, "$1").replace(stringOrTrailingCommaRe, "$1")); + } + } +}; +var dist_default = JSONC; + +// src/patchers/patcher.ts +var Patcher = class _Patcher { + constructor(plugin) { + this.plugin = plugin; + this.patch(); + } + static async waitForMapValueLookup(map, viewType, patch) { + return new Promise((resolve) => { + const uninstaller = around(map, { + [viewType]: (next) => function(...args) { + const view = next.call(this, ...args); + patch(view); + const patchedView = next.call(this, ...args); + uninstaller(); + resolve(patchedView); + return patchedView; + } + }); + }); + } + static async waitForViewRequest(plugin, viewType, patch) { + return this.waitForMapValueLookup(plugin.app.viewRegistry.viewByType, viewType, patch); + } + static OverrideExisting(fn) { + return Object.assign(fn, { __overrideExisting: true }); + } + static patchThisAndPrototype(plugin, object, patches, uninstallers) { + _Patcher.patch(plugin, object, patches, false, uninstallers); + return _Patcher.patchPrototype(plugin, object, patches, uninstallers); + } + static patchPrototype(plugin, target, patches, uninstallers) { + return _Patcher.patch(plugin, target, patches, true, uninstallers); + } + static patch(plugin, object, patches, prototype = false, uninstallers) { + if (!object) return null; + const target = prototype ? object.constructor.prototype : object; + for (const key of Object.keys(patches)) { + const patch = patches[key]; + if (patch == null ? void 0 : patch.__overrideExisting) { + if (typeof target[key] !== "function") + throw new Error(`Method ${String(key)} does not exist on target`); + } + } + const uninstaller = around(target, patches); + if (uninstallers) uninstallers.push(uninstaller); + plugin.register(uninstaller); + return object; + } + static async patchOnce(plugin, object, patches) { + const uninstallers = []; + const value = await new Promise( + (resolve) => this.patch(plugin, object, patches(resolve), false, uninstallers) + ); + for (const uninstall of uninstallers) uninstall(); + return value; + } + static tryPatchWorkspacePrototype(plugin, getTarget, patches, uninstallers) { + return new Promise((resolve) => { + const result = _Patcher.patchPrototype(plugin, getTarget(), patches, uninstallers); + if (result) { + resolve(result); + return; + } + const listener = plugin.app.workspace.on("layout-change", () => { + const result2 = _Patcher.patchPrototype(plugin, getTarget(), patches, uninstallers); + if (result2) { + plugin.app.workspace.offref(listener); + resolve(result2); + } + }); + plugin.registerEvent(listener); + }); + } +}; + +// src/utils/migration-helper.ts +var CURRENT_SPEC_VERSION = "1.0-1.0"; +var _MigrationHelper = class _MigrationHelper { + static needsMigration(canvas) { + var _a; + return ((_a = canvas.metadata) == null ? void 0 : _a.version) !== CURRENT_SPEC_VERSION; + } + static migrate(canvas) { + var _a, _b; + let version = (_b = (_a = canvas.metadata) == null ? void 0 : _a.version) != null ? _b : "undefined"; + if (version === CURRENT_SPEC_VERSION) return canvas; + while (version !== CURRENT_SPEC_VERSION) { + const migrationFunction = _MigrationHelper.MIGRATIONS[version]; + if (!migrationFunction) { + console.error(`No migration function found for version ${version}. Critical error!`); + break; + } + const { version: newVersion, canvas: migratedCanvas } = migrationFunction(canvas); + version = newVersion; + canvas = migratedCanvas; + if (!canvas.metadata) canvas.metadata = { version, frontmatter: {} }; + else canvas.metadata.version = version; + } + return canvas; + } +}; +_MigrationHelper.MIGRATIONS = { + undefined: (canvas) => { + var _a, _b, _c; + const TARGET_SPEC_VERSION = "1.0-1.0"; + let startNode; + const globalInterdimensionalEdges = {}; + for (const node of (_a = canvas.nodes) != null ? _a : []) { + node.dynamicHeight = node.autoResizeHeight; + delete node.autoResizeHeight; + node.ratio = node.sideRatio; + delete node.sideRatio; + node.collapsed = node.isCollapsed; + delete node.isCollapsed; + if (node.portalToFile) { + node.portal = true; + delete node.portalToFile; + } + if (node.isStartNode) { + startNode = node.id; + delete node.isStartNode; + } + if (node.edgesToNodeFromPortal) { + const edgesToNodeFromPortal = node.edgesToNodeFromPortal; + for (const [portalId, edges] of Object.entries(edgesToNodeFromPortal)) { + if (!(portalId in globalInterdimensionalEdges)) globalInterdimensionalEdges[portalId] = []; + for (const edge of edges) { + if (edge.fromNode !== node.id) edge.fromNode = `${portalId}-${edge.fromNode}`; + if (edge.toNode !== node.id) edge.toNode = `${portalId}-${edge.toNode}`; + } + globalInterdimensionalEdges[portalId].push(...edges); + } + delete node.edgesToNodeFromPortal; + } + } + for (const node of (_b = canvas.nodes) != null ? _b : []) { + if (!(node.id in globalInterdimensionalEdges)) continue; + node.interdimensionalEdges = globalInterdimensionalEdges[node.id]; + } + (_c = canvas.metadata) != null ? _c : canvas.metadata = { + version: TARGET_SPEC_VERSION, + frontmatter: {}, + startNode + }; + return { version: TARGET_SPEC_VERSION, canvas }; + } +}; +var MigrationHelper = _MigrationHelper; + +// src/patchers/canvas-patcher.ts +var CanvasPatcher = class extends Patcher { + async patch() { + const loadedCanvasViewLeafs = this.plugin.app.workspace.getLeavesOfType("canvas").filter((leaf) => !(0, import_obsidian5.requireApiVersion)("1.7.2") || !leaf.isDeferred); + if (loadedCanvasViewLeafs.length > 0) { + console.debug(`Patching and reloading loaded canvas views (Count: ${loadedCanvasViewLeafs.length})`); + this.patchCanvas(loadedCanvasViewLeafs.first().view); + for (const leaf of loadedCanvasViewLeafs) leaf.rebuildView(); + } else { + await Patcher.waitForViewRequest(this.plugin, "canvas", (view) => this.patchCanvas(view)); + console.debug(`Patched canvas view on first request`); + } + } + patchCanvas(view) { + const that = this; + Patcher.patchPrototype(this.plugin, view, { + setEphemeralState: Patcher.OverrideExisting((next) => function(state) { + var _a, _b, _c; + if (state == null ? void 0 : state.subpath) { + const nodeId = state.subpath.replace(/^#/, ""); + const node = this.canvas.nodes.get(nodeId); + if (node) { + this.canvas.selectOnly(node); + this.canvas.zoomToSelection(); + return; + } + } + if (((_b = (_a = state.match) == null ? void 0 : _a.matches) == null ? void 0 : _b[0]) && !((_c = state.match) == null ? void 0 : _c.nodeId)) { + const match = state.match.matches[0]; + const elementType = match[0] === 0 ? "nodes" : "edges"; + const elementIndex = match[1]; + const element = elementType === "nodes" ? Array.from(this.canvas.nodes.values())[elementIndex] : Array.from(this.canvas.edges.values())[elementIndex]; + if (element) { + this.canvas.selectOnly(element); + this.canvas.zoomToSelection(); + return; + } + } + return next.call(this, state); + }), + setViewData: Patcher.OverrideExisting((next) => function(json, ...args) { + json = json !== "" ? json : '{"nodes": [], "edges": []}'; + try { + const canvasData = dist_default.parse(json); + if (MigrationHelper.needsMigration(canvasData)) { + if (this.file) that.plugin.createFileSnapshot(this.file.path, json); + json = JSON.stringify(MigrationHelper.migrate(canvasData)); + } + } catch (e) { + console.error("Failed to migrate canvas data:", e); + } + let result; + try { + result = next.call(this, json, ...args); + } catch (e) { + console.error("Invalid JSON, repairing through Advanced Canvas:", e); + if (this.file) that.plugin.createFileSnapshot(this.file.path, json); + json = JSON.stringify(dist_default.parse(json), null, 2); + result = next.call(this, json, ...args); + } + that.plugin.app.workspace.trigger("advanced-canvas:canvas-changed", this.canvas); + return result; + }), + close: Patcher.OverrideExisting((next) => function(...args) { + that.plugin.app.workspace.trigger("advanced-canvas:canvas-view-unloaded:before", this); + return next.call(this, ...args); + }) + }); + Patcher.patchPrototype(this.plugin, view.canvas, { + markViewportChanged: Patcher.OverrideExisting((next) => function(...args) { + that.plugin.app.workspace.trigger("advanced-canvas:viewport-changed:before", this); + const result = next.call(this, ...args); + that.plugin.app.workspace.trigger("advanced-canvas:viewport-changed:after", this); + return result; + }), + markMoved: Patcher.OverrideExisting((next) => function(node) { + const result = next.call(this, node); + if (!this.viewportChanged) { + if (node.prevX !== node.x || node.prevY !== node.y) + that.plugin.app.workspace.trigger("advanced-canvas:node-moved", this, node, !this.isDragging); + if (node.prevWidth !== node.width || node.prevHeight !== node.height) + that.plugin.app.workspace.trigger("advanced-canvas:node-resized", this, node); + } + node.prevX = node.x; + node.prevY = node.y; + node.prevWidth = node.width; + node.prevHeight = node.height; + return result; + }), + onDoubleClick: Patcher.OverrideExisting((next) => function(event) { + const preventDefault = { value: false }; + that.plugin.app.workspace.trigger("advanced-canvas:double-click", this, event, preventDefault); + if (!preventDefault.value) next.call(this, event); + }), + setDragging: Patcher.OverrideExisting((next) => function(dragging) { + const result = next.call(this, dragging); + that.plugin.app.workspace.trigger("advanced-canvas:dragging-state-changed", this, dragging); + return result; + }), + // OBSIDIAN-FIX + cloneData: Patcher.OverrideExisting((next) => function(elements, shift) { + const result = next.call(this, elements, shift); + elements.nodes = elements.nodes.map((nodeData) => JSON.parse(JSON.stringify(nodeData))); + elements.edges = elements.edges.map((edgeData) => JSON.parse(JSON.stringify(edgeData))); + return result; + }), + getContainingNodes: Patcher.OverrideExisting((next) => function(bbox) { + const result = next.call(this, bbox); + that.plugin.app.workspace.trigger("advanced-canvas:containing-nodes-requested", this, bbox, result); + return result; + }), + updateSelection: Patcher.OverrideExisting((next) => function(update) { + const oldSelection = new Set(this.selection); + const result = next.call(this, update); + that.plugin.app.workspace.trigger("advanced-canvas:selection-changed", this, oldSelection, (update2) => next.call(this, update2)); + return result; + }), + createTextNode: Patcher.OverrideExisting((next) => function(...args) { + const node = next.call(this, ...args); + that.plugin.app.workspace.trigger("advanced-canvas:node-created", this, node); + return node; + }), + createFileNode: Patcher.OverrideExisting((next) => function(...args) { + const node = next.call(this, ...args); + that.plugin.app.workspace.trigger("advanced-canvas:node-created", this, node); + return node; + }), + createFileNodes: Patcher.OverrideExisting((next) => function(...args) { + const nodes = next.call(this, ...args); + nodes.forEach((node) => that.plugin.app.workspace.trigger("advanced-canvas:node-created", this, node)); + return nodes; + }), + createGroupNode: Patcher.OverrideExisting((next) => function(...args) { + const node = next.call(this, ...args); + that.plugin.app.workspace.trigger("advanced-canvas:node-created", this, node); + return node; + }), + createLinkNode: Patcher.OverrideExisting((next) => function(...args) { + const node = next.call(this, ...args); + that.plugin.app.workspace.trigger("advanced-canvas:node-created", this, node); + return node; + }), + addNode: Patcher.OverrideExisting((next) => function(node) { + that.patchNode(node); + return next.call(this, node); + }), + addEdge: Patcher.OverrideExisting((next) => function(edge) { + that.patchEdge(edge); + if (!this.viewportChanged) that.plugin.app.workspace.trigger("advanced-canvas:edge-created", this, edge); + return next.call(this, edge); + }), + removeNode: Patcher.OverrideExisting((next) => function(node) { + const result = next.call(this, node); + if (!this.isClearing) that.plugin.app.workspace.trigger("advanced-canvas:node-removed", this, node); + return result; + }), + removeEdge: Patcher.OverrideExisting((next) => function(edge) { + const result = next.call(this, edge); + if (!this.isClearing) that.plugin.app.workspace.trigger("advanced-canvas:edge-removed", this, edge); + return result; + }), + handleCopy: Patcher.OverrideExisting((next) => function(...args) { + this.isCopying = true; + const result = next.call(this, ...args); + this.isCopying = false; + return result; + }), + handlePaste: Patcher.OverrideExisting((next) => function(...args) { + this.isPasting = true; + const result = next.call(this, ...args); + this.isPasting = false; + return result; + }), + getSelectionData: Patcher.OverrideExisting((next) => function(...args) { + const result = next.call(this, ...args); + if (this.isCopying) that.plugin.app.workspace.trigger("advanced-canvas:copy", this, result); + return result; + }), + zoomToBbox: Patcher.OverrideExisting((next) => function(bbox) { + that.plugin.app.workspace.trigger("advanced-canvas:zoom-to-bbox:before", this, bbox); + const result = next.call(this, bbox); + that.plugin.app.workspace.trigger("advanced-canvas:zoom-to-bbox:after", this, bbox); + return result; + }), + // Custom + zoomToRealBbox: (_next) => function(bbox) { + if (this.canvasRect.width === 0 || this.canvasRect.height === 0) return; + that.plugin.app.workspace.trigger("advanced-canvas:zoom-to-bbox:before", this, bbox); + const widthZoom = this.canvasRect.width / (bbox.maxX - bbox.minX); + const heightZoom = this.canvasRect.height / (bbox.maxY - bbox.minY); + const zoom = this.screenshotting ? Math.min(widthZoom, heightZoom) : Math.clamp(Math.min(widthZoom, heightZoom), -4, 1); + this.tZoom = Math.log2(zoom); + this.zoomCenter = null; + this.tx = (bbox.minX + bbox.maxX) / 2; + this.ty = (bbox.minY + bbox.maxY) / 2; + this.markViewportChanged(); + that.plugin.app.workspace.trigger("advanced-canvas:zoom-to-bbox:after", this, bbox); + }, + setReadonly: Patcher.OverrideExisting((next) => function(readonly) { + const result = next.call(this, readonly); + that.plugin.app.workspace.trigger("advanced-canvas:readonly-changed", this, readonly); + return result; + }), + undo: Patcher.OverrideExisting((next) => function(...args) { + const result = next.call(this, ...args); + this.importData(this.getData(), true); + that.plugin.app.workspace.trigger("advanced-canvas:undo", this); + return result; + }), + redo: Patcher.OverrideExisting((next) => function(...args) { + const result = next.call(this, ...args); + this.importData(this.getData(), true); + that.plugin.app.workspace.trigger("advanced-canvas:redo", this); + return result; + }), + clear: Patcher.OverrideExisting((next) => function(...args) { + this.isClearing = true; + const result = next.call(this, ...args); + this.isClearing = false; + return result; + }), + /*setData: Patcher.OverrideExisting(next => function (...args: any): void { + // + const result = next.call(this, ...args) + // + return result + }),*/ + getData: Patcher.OverrideExisting((next) => function(...args) { + const result = next.call(this, ...args); + that.plugin.app.workspace.trigger("advanced-canvas:data-requested", this, result); + return result; + }), + importData: Patcher.OverrideExisting((next) => function(data, clearCanvas, silent) { + var _a; + const targetFilePath = (_a = this.view.file) == null ? void 0 : _a.path; + const setData = (data2) => { + if (!this.view.file || this.view.file.path !== targetFilePath) return; + this.importData(data2, true, true); + }; + if (!silent) that.plugin.app.workspace.trigger("advanced-canvas:data-loaded:before", this, data, setData); + const result = next.call(this, data, clearCanvas); + if (!silent) that.plugin.app.workspace.trigger("advanced-canvas:data-loaded:after", this, data, setData); + return result; + }), + requestSave: Patcher.OverrideExisting((next) => function(...args) { + that.plugin.app.workspace.trigger("advanced-canvas:canvas-saved:before", this); + const result = next.call(this, ...args); + that.plugin.app.workspace.trigger("advanced-canvas:canvas-saved:after", this); + return result; + }) + }); + Patcher.patchPrototype(this.plugin, view.canvas.menu, { + render: Patcher.OverrideExisting((next) => function(...args) { + const result = next.call(this, ...args); + that.plugin.app.workspace.trigger("advanced-canvas:popup-menu-created", this.canvas); + next.call(this); + return result; + }) + }); + Patcher.patchPrototype(this.plugin, view.canvas.nodeInteractionLayer, { + setTarget: Patcher.OverrideExisting((next) => function(node) { + const result = next.call(this, node); + that.plugin.app.workspace.trigger("advanced-canvas:node-interaction", this.canvas, node); + return result; + }) + }); + this.plugin.registerEditorExtension([import_view.EditorView.updateListener.of((update) => { + if (!update.docChanged) return; + const editor = update.state.field(import_obsidian5.editorInfoField); + const node = editor.node; + if (!node) return; + that.plugin.app.workspace.trigger("advanced-canvas:node-text-content-changed", node.canvas, node, update); + })]); + } + patchNode(node) { + const that = this; + Patcher.patch(this.plugin, node, { + setData: Patcher.OverrideExisting((next) => function(data, addHistory) { + const result = next.call(this, data); + if (node.initialized && !node.isDirty) { + node.isDirty = true; + that.plugin.app.workspace.trigger("advanced-canvas:node-changed", this.canvas, node); + delete node.isDirty; + } + this.canvas.data = this.canvas.getData(); + if (this.initialized) this.canvas.view.requestSave(); + if (addHistory) this.canvas.pushHistory(this.canvas.data); + return result; + }), + setZIndex: (_next) => function(value) { + this.setData({ + ...this.getData(), + zIndex: value + }, true); + this.updateZIndex(); + }, + updateZIndex: Patcher.OverrideExisting((next) => function() { + const persistentZIndex = this.getData().zIndex; + if (persistentZIndex === void 0) return next.call(this); + this.canvas.zIndexCounter = Math.max(this.canvas.zIndexCounter, persistentZIndex); + this.renderZIndex(); + }), + renderZIndex: Patcher.OverrideExisting((next) => function() { + const persistentZIndex = this.getData().zIndex; + if (persistentZIndex === void 0) return next.call(this); + this.zIndex = persistentZIndex; + if (this.canvas.selection.size === 1 && this.canvas.selection.has(this)) + this.zIndex = this.canvas.zIndexCounter + 1; + this.nodeEl.style.zIndex = this.zIndex.toString(); + }), + setIsEditing: Patcher.OverrideExisting((next) => function(editing, ...args) { + const result = next.call(this, editing, ...args); + that.plugin.app.workspace.trigger("advanced-canvas:node-editing-state-changed", this.canvas, node, editing); + return result; + }), + updateBreakpoint: Patcher.OverrideExisting((next) => function(breakpoint) { + const breakpointRef = { value: breakpoint }; + that.plugin.app.workspace.trigger("advanced-canvas:node-breakpoint-changed", this.canvas, node, breakpointRef); + return next.call(this, breakpointRef.value); + }), + getBBox: Patcher.OverrideExisting((next) => function(...args) { + const result = next.call(this, ...args); + that.plugin.app.workspace.trigger("advanced-canvas:node-bbox-requested", this.canvas, node, result); + return result; + }), + onConnectionPointerdown: Patcher.OverrideExisting((next) => function(e, side) { + const addEdgeEventRef = that.plugin.app.workspace.on("advanced-canvas:edge-added", (_canvas, edge) => { + that.plugin.app.workspace.trigger("advanced-canvas:edge-connection-dragging:before", this.canvas, edge, e, true, "to"); + that.plugin.app.workspace.offref(addEdgeEventRef); + document.addEventListener("pointerup", (e2) => { + that.plugin.app.workspace.trigger("advanced-canvas:edge-connection-dragging:after", this.canvas, edge, e2, true, "to"); + }, { once: true }); + }); + const result = next.call(this, e, side); + return result; + }), + // File nodes + setFile: (next) => function(...args) { + const result = next.call(this, ...args); + that.plugin.app.workspace.trigger("advanced-canvas:node-changed", this.canvas, this); + return result; + }, + setFilePath: (next) => function(...args) { + const result = next.call(this, ...args); + that.plugin.app.workspace.trigger("advanced-canvas:node-changed", this.canvas, this); + return result; + } + }); + this.runAfterInitialized(node, () => { + this.plugin.app.workspace.trigger("advanced-canvas:node-added", node.canvas, node); + this.plugin.app.workspace.trigger("advanced-canvas:node-changed", node.canvas, node); + }); + } + patchEdge(edge) { + const that = this; + Patcher.patch(this.plugin, edge, { + setData: Patcher.OverrideExisting((next) => function(data, addHistory) { + const result = next.call(this, data); + if (this.initialized && !this.isDirty) { + this.isDirty = true; + that.plugin.app.workspace.trigger("advanced-canvas:edge-changed", this.canvas, this); + delete this.isDirty; + } + this.canvas.data = this.canvas.getData(); + if (this.initialized) this.canvas.view.requestSave(); + if (addHistory) this.canvas.pushHistory(this.canvas.getData()); + return result; + }), + render: Patcher.OverrideExisting((next) => function(...args) { + const result = next.call(this, ...args); + that.plugin.app.workspace.trigger("advanced-canvas:edge-changed", this.canvas, this); + return result; + }), + getCenter: Patcher.OverrideExisting((next) => function(...args) { + const result = next.call(this, ...args); + that.plugin.app.workspace.trigger("advanced-canvas:edge-center-requested", this.canvas, this, result); + return result; + }), + onConnectionPointerdown: Patcher.OverrideExisting((next) => function(e) { + const cancelRef = { value: false }; + that.plugin.app.workspace.trigger("advanced-canvas:edge-connection-try-dragging:before", this.canvas, this, e, cancelRef); + if (cancelRef.value) return; + const previousEnds = { from: this.from, to: this.to }; + const result = next.call(this, e); + const eventPos = this.canvas.posFromEvt(e); + const fromPos = BBoxHelper.getCenterOfBBoxSide(this.from.node.getBBox(), this.from.side); + const toPos = BBoxHelper.getCenterOfBBoxSide(this.to.node.getBBox(), this.to.side); + const draggingSide = Math.hypot(eventPos.x - fromPos.x, eventPos.y - fromPos.y) > Math.hypot(eventPos.x - toPos.x, eventPos.y - toPos.y) ? "to" : "from"; + that.plugin.app.workspace.trigger("advanced-canvas:edge-connection-dragging:before", this.canvas, this, e, false, draggingSide, previousEnds); + document.addEventListener("pointerup", (e2) => { + that.plugin.app.workspace.trigger("advanced-canvas:edge-connection-dragging:after", this.canvas, this, e2, false, draggingSide, previousEnds); + }, { once: true }); + return result; + }) + }); + this.runAfterInitialized(edge, () => { + this.plugin.app.workspace.trigger("advanced-canvas:edge-added", edge.canvas, edge); + }); + } + runAfterInitialized(canvasElement, onReady) { + if (canvasElement.initialized) { + onReady(); + return; + } + const that = this; + const uninstall = around(canvasElement, { + initialize: (next) => function(...args) { + const result = next.call(this, ...args); + onReady(); + uninstall(); + return result; + } + }); + that.plugin.register(uninstall); + } +}; + +// src/patchers/link-suggestions-patcher.ts +var import_obsidian6 = require("obsidian"); +var LinkSuggestionsPatcher = class extends Patcher { + async patch() { + var _a; + if (!this.plugin.settings.getSetting("enableSingleNodeLinks")) return; + const suggestManager = (_a = this.plugin.app.workspace.editorSuggest.suggests.find((s) => s.suggestManager)) == null ? void 0 : _a.suggestManager; + if (!suggestManager) return console.warn("LinkSuggestionsPatcher: No suggest manager found."); + Patcher.patchThisAndPrototype(this.plugin, suggestManager, { + getHeadingSuggestions: Patcher.OverrideExisting((next) => async function(context, path, subpath) { + const result = await next.call(this, context, path, subpath); + if (!path.endsWith(".canvas")) return result; + const currentFilePath = this.getSourcePath(); + const targetFile = this.app.metadataCache.getFirstLinkpathDest(path, currentFilePath); + if (!targetFile) return result; + if (!(targetFile instanceof import_obsidian6.TFile) || targetFile.extension !== "canvas") + return result; + const fileCache = this.app.metadataCache.getFileCache(targetFile); + if (!fileCache) return result; + const canvasNodeCaches = fileCache.nodes; + if (!canvasNodeCaches) return result; + for (const nodeId of Object.keys(canvasNodeCaches)) { + if (nodeId === subpath) continue; + const suggestion = { + file: targetFile, + heading: nodeId, + level: 1, + matches: [], + path, + subpath: `#${nodeId}`, + score: 0, + type: "heading" + }; + result.push(suggestion); + } + return result; + }) + }); + } +}; + +// src/advanced-canvas-embed.ts +var import_obsidian7 = require("obsidian"); +var AdvancedCanvasEmbed = class extends import_obsidian7.Component { + constructor(context, file, subpath) { + super(); + this.onModifyCallback = (file) => { + if (file.path !== this.file.path) return; + this.loadFile(); + }; + this.context = context; + this.file = file; + this.subpath = subpath; + if (!subpath) console.warn("AdvancedCanvasEmbed: No subpath provided. This embed will not work as expected."); + } + onload() { + this.context.app.vault.on("modify", this.onModifyCallback); + } + onunload() { + this.context.app.vault.off("modify", this.onModifyCallback); + } + async loadFile() { + if (!this.subpath) return; + const nodeId = this.subpath.replace(/^#/, ""); + const canvasContent = await this.context.app.vault.cachedRead(this.file); + if (!canvasContent) return console.warn("AdvancedCanvasEmbed: No canvas content found."); + const canvasJson = JSON.parse(canvasContent); + const canvasNode = canvasJson.nodes.find((node) => node.id === nodeId); + if (!canvasNode) { + this.context.containerEl.classList.add("mod-empty"); + this.context.containerEl.textContent = "Node not found"; + return; + } + let nodeContent = ""; + if (canvasNode.type === "text") nodeContent = canvasNode.text; + else if (canvasNode.type === "group") nodeContent = `**Group Node:** ${canvasNode.label}`; + else if (canvasNode.type === "file") nodeContent = `**File Node:** ${canvasNode.file}`; + this.context.containerEl.classList.add("markdown-embed"); + this.context.containerEl.empty(); + import_obsidian7.MarkdownRenderer.render(this.context.app, nodeContent, this.context.containerEl, this.file.path, this); + } +}; + +// src/patchers/embed-patcher.ts +var EmbedPatcher = class extends Patcher { + async patch() { + if (!this.plugin.settings.getSetting("enableSingleNodeLinks")) return; + Patcher.patch(this.plugin, this.plugin.app.embedRegistry.embedByExtension, { + canvas: (next) => function(context, file, subpath) { + if (subpath) return new AdvancedCanvasEmbed(context, file, subpath); + return next.call(this, context, file, subpath); + } + }); + } +}; + +// src/patchers/metadata-cache-patcher.ts +var import_obsidian8 = require("obsidian"); + +// src/utils/filepath-helper.ts +var FilepathHelper = class { + static extension(path) { + var _a; + return (path == null ? void 0 : path.includes(".")) ? (_a = path == null ? void 0 : path.split(".")) == null ? void 0 : _a.pop() : void 0; + } +}; + +// src/utils/hash-helper.ts +var HashHelper = class _HashHelper { + static async getBytesHash(bytes) { + const cryptoBytes = await crypto.subtle.digest("SHA-256", new Uint8Array(bytes)); + return _HashHelper.arrayBufferToHexString(cryptoBytes); + } + static arrayBufferToHexString(buffer) { + const uint8Array = new Uint8Array(buffer); + const hexArray = []; + for (const byte of uint8Array) { + hexArray.push((byte >>> 4).toString(16)); + hexArray.push((byte & 15).toString(16)); + } + return hexArray.join(""); + } +}; + +// src/utils/task-queue.ts +var TaskQueue = class { + constructor() { + this.running = false; + this.queue = []; + this.onFinished = () => { + }; + } + async add(task) { + return new Promise((resolve) => { + this.queue.push([resolve, task]); + if (!this.running) this.run(); + }); + } + setOnFinished(callback) { + this.onFinished = callback; + } + async run() { + var _a; + this.running = true; + while (this.queue.length > 0) { + const [resolver, task] = (_a = this.queue.shift()) != null ? _a : [void 0, void 0]; + await (task == null ? void 0 : task()); + resolver == null ? void 0 : resolver(); + } + this.running = false; + this.onFinished(); + } +}; + +// src/patchers/metadata-cache-patcher.ts +var MetadataCachePatcher = class extends Patcher { + async patch() { + if (!this.plugin.settings.getSetting("canvasMetadataCompatibilityEnabled")) return; + Patcher.patchPrototype(this.plugin, this.plugin.app.metadataCache, { + getCache: Patcher.OverrideExisting((next) => function(filepath, ...args) { + if (FilepathHelper.extension(filepath) === "canvas") { + if (!this.fileCache.hasOwnProperty(filepath)) return null; + const hash = this.fileCache[filepath].hash; + return this.metadataCache[hash] || null; + } + return next.call(this, filepath, ...args); + }), + computeFileMetadataAsync: Patcher.OverrideExisting((next) => async function(file, ...args) { + if (file instanceof import_obsidian8.TFile && (file == null ? void 0 : file.extension) === "canvas") + return CanvasMetadataHandler.computeCanvasFileMetadataAsync.call(this, file); + return next.call(this, file, ...args); + }), + resolveLinks: Patcher.OverrideExisting((next) => async function(filepath) { + const result = next.call(this, filepath); + if (FilepathHelper.extension(filepath) === "canvas") + CanvasMetadataHandler.resolveCanvasLinks.call(this, filepath); + return result; + }) + }); + } +}; +var _CanvasMetadataHandler = class _CanvasMetadataHandler { + static async computeCanvasFileMetadataAsync(file) { + this.uniqueFileLookup.add(file.name.toLowerCase(), file); + let isStale = true; + if (!this.fileCache.hasOwnProperty(file.path)) + this.saveFileCache(file.path, { mtime: 0, size: 0, hash: "" }); + else { + const cache2 = this.fileCache[file.path]; + const unchanged = cache2.mtime === file.stat.mtime && cache2.size === file.stat.size; + const hasMetadataCache = cache2.hash && this.metadataCache.hasOwnProperty(cache2.hash); + if (unchanged && hasMetadataCache) + isStale = false; + } + if (isStale) { + _CanvasMetadataHandler.linkResolveQueue.setOnFinished(() => this.trigger("finished")); + await _CanvasMetadataHandler.metadataQueue.add( + () => _CanvasMetadataHandler.updateMetadataCache.call(this, file) + ); + } + _CanvasMetadataHandler.linkResolveQueue.setOnFinished(() => this.trigger("resolved")); + await _CanvasMetadataHandler.linkResolveQueue.add( + () => _CanvasMetadataHandler.resolveCanvasLinks.call(this, file.path) + ); + } + static async updateMetadataCache(file) { + const bytes = await this.vault.readBinary(file); + const data = new TextDecoder().decode(new Uint8Array(bytes)); + const hash = await HashHelper.getBytesHash(bytes); + const cache2 = { + mtime: file.stat.mtime, + size: file.stat.size, + hash + }; + this.saveFileCache(file.path, cache2); + let metadata = this.metadataCache[cache2.hash]; + if (metadata) return this.trigger( + "changed", + file, + data, + metadata + ); + const slowIndexingTimeout = setTimeout(() => { + new import_obsidian8.Notice(`Canvas indexing taking a long time for file ${file.path}`); + }, 1e4); + try { + metadata = await _CanvasMetadataHandler.computeCanvasMetadataAsync.call(this, data); + } finally { + clearTimeout(slowIndexingTimeout); + } + if (metadata) { + this.saveMetaCache(hash, metadata); + this.trigger("changed", file, data, metadata); + } else { + console.log("Canvas metadata failed to parse", file); + } + } + static async computeCanvasMetadataAsync(data) { + var _a, _b, _c, _d, _e; + const content = JSON.parse(data || "{}"); + const metadata = { + v: 1 + }; + const frontmatter = (_a = content.metadata) == null ? void 0 : _a.frontmatter; + metadata.frontmatterPosition = { + start: { line: 0, col: 0, offset: 0 }, + end: { line: 0, col: 0, offset: 0 } + }; + metadata.frontmatter = frontmatter; + metadata.frontmatterLinks = []; + for (const [key, value] of Object.entries(frontmatter != null ? frontmatter : {})) { + const getLinks = (value2) => value2.map((v) => { + if (!v.startsWith("[[") || !v.endsWith("]]")) return null; + const [link, ...aliases] = v.slice(2, -2).split("|"); + return { + key, + displayText: aliases.length > 0 ? aliases.join("|") : link, + link, + original: v + }; + }).filter((v) => v !== null); + if (typeof value === "string") (_b = metadata.frontmatterLinks) == null ? void 0 : _b.push(...getLinks([value])); + else if (Array.isArray(value)) (_c = metadata.frontmatterLinks) == null ? void 0 : _c.push(...getLinks(value)); + } + metadata.nodes = {}; + metadata.links = []; + metadata.embeds = []; + await Promise.all(((_d = content.nodes) != null ? _d : []).map(async (node, index) => { + var _a2, _b2; + if (node.type !== "text") return; + const text = node.text; + const buffer = new TextEncoder().encode(text).buffer; + const nodeMetadata = await this.computeMetadataAsync(buffer); + if (!nodeMetadata) return; + metadata.nodes[node.id] = nodeMetadata; + metadata.links.push(...((_a2 = nodeMetadata.links) != null ? _a2 : []).map((link) => ({ + ...link, + position: { + nodeId: node.id, + start: { line: 0, col: 1, offset: 0 }, + // 0 for node + end: { line: 0, col: 1, offset: index } + // index of node + } + }))); + metadata.embeds.push(...((_b2 = nodeMetadata.embeds) != null ? _b2 : []).map((embed2) => ({ + ...embed2, + position: { + nodeId: node.id, + start: { line: 0, col: 1, offset: 0 }, + // 0 for node + end: { line: 0, col: 1, offset: index } + // index of node + } + }))); + })); + for (const [index, node] of ((_e = content.nodes) != null ? _e : []).entries()) { + if (node.type !== "file") continue; + const file = node.file; + if (!file) continue; + metadata.embeds.push({ + link: file, + original: file, + displayText: file, + position: { + start: { line: 0, col: 1, offset: 0 }, + // 0 for nodes + end: { line: 0, col: 1, offset: index } + // index of node + } + }); + } + return metadata; + } + static async resolveCanvasLinks(filepath) { + var _a, _b, _c, _d, _e; + const file = this.vault.getAbstractFileByPath(filepath); + if (!(file instanceof import_obsidian8.TFile)) return; + const metadata = this.getFileCache(file); + const references = [...(_a = metadata == null ? void 0 : metadata.links) != null ? _a : [], ...(_b = metadata == null ? void 0 : metadata.embeds) != null ? _b : []]; + const referenceLinks = references.map((ref) => ref.link).sort(); + const resolvedLinks = {}; + const unresolvedLinks = {}; + for (const link of referenceLinks) { + const resolved = this.getFirstLinkpathDest(link, filepath); + if (resolved) { + (_d = resolvedLinks[_c = resolved.path]) != null ? _d : resolvedLinks[_c] = 0; + resolvedLinks[resolved.path]++; + } else { + const strippedLink = link.endsWith(".md") ? link.slice(0, -3) : link; + (_e = unresolvedLinks[strippedLink]) != null ? _e : unresolvedLinks[strippedLink] = 0; + unresolvedLinks[strippedLink]++; + } + } + this.resolvedLinks[filepath] = resolvedLinks; + this.unresolvedLinks[filepath] = unresolvedLinks; + await sleep(1); + this.trigger("resolve", file); + } +}; +_CanvasMetadataHandler.metadataQueue = new TaskQueue(); +_CanvasMetadataHandler.linkResolveQueue = new TaskQueue(); +var CanvasMetadataHandler = _CanvasMetadataHandler; + +// src/patchers/backlinks-patcher.ts +var import_obsidian9 = require("obsidian"); +var BacklinksPatcher = class extends Patcher { + constructor() { + super(...arguments); + this.isRecomputingBacklinks = false; + } + async patch() { + if (!this.plugin.settings.getSetting("canvasMetadataCompatibilityEnabled")) return; + const that = this; + await Patcher.waitForViewRequest(this.plugin, "backlink", (view) => { + Patcher.patchPrototype(this.plugin, view.backlink, { + recomputeBacklink: Patcher.OverrideExisting((next) => function(file, ...args) { + that.isRecomputingBacklinks = true; + const result = next.call(this, file, ...args); + that.isRecomputingBacklinks = false; + return result; + }) + }); + }); + Patcher.patchPrototype(this.plugin, this.plugin.app.vault, { + recurseChildrenAC: (_next) => function(origin, traverse) { + for (let stack = [origin]; stack.length > 0; ) { + const current = stack.pop(); + if (current) { + traverse(current); + if (current instanceof import_obsidian9.TFolder) stack = stack.concat(current.children); + } + } + }, + getMarkdownFiles: Patcher.OverrideExisting((next) => function(...args) { + if (!that.isRecomputingBacklinks) return next.call(this, ...args); + const files = []; + const root = this.getRoot(); + this.recurseChildrenAC(root, (child) => { + if (child instanceof import_obsidian9.TFile && (child.extension === "md" || child.extension === "canvas")) { + files.push(child); + } + }); + return files; + }) + }); + } +}; + +// src/patchers/outgoing-links-patcher.ts +var OutgoingLinksPatcher = class extends Patcher { + async patch() { + if (!this.plugin.settings.getSetting("canvasMetadataCompatibilityEnabled")) return; + await Patcher.waitForViewRequest(this.plugin, "outgoing-link", (view) => { + Patcher.patchPrototype(this.plugin, view.outgoingLink, { + recomputeLinks: Patcher.OverrideExisting((next) => function(...args) { + var _a; + const isCanvas = ((_a = this.file) == null ? void 0 : _a.extension) === "canvas"; + if (isCanvas) this.file.extension = "md"; + const result = next.call(this, ...args); + if (isCanvas) this.file.extension = "canvas"; + return result; + }), + recomputeUnlinked: Patcher.OverrideExisting((next) => function(...args) { + var _a; + const isCanvas = ((_a = this.file) == null ? void 0 : _a.extension) === "canvas"; + if (isCanvas) this.file.extension = "md"; + const result = next.call(this, ...args); + if (isCanvas) this.file.extension = "canvas"; + return result; + }) + }); + }); + } +}; + +// src/patchers/file-manager-patcher.ts +var FileManagerPatcher = class extends Patcher { + async patch() { + if (!this.plugin.settings.getSetting("canvasMetadataCompatibilityEnabled")) return; + const that = this; + Patcher.patch(this.plugin, this.plugin.app.fileManager, { + processFrontMatter: Patcher.OverrideExisting((next) => async function(file, fn, options) { + if ((file == null ? void 0 : file.extension) === "canvas") { + that.plugin.app.vault.process(file, (data) => { + const content = JSON.parse(data); + fn(content.metadata.frontmatter); + return JSON.stringify(content, null, 2); + }); + return; + } + return next.call(this, file, fn, options); + }) + }); + } +}; + +// src/patchers/properties-patcher.ts +var PropertiesPatcher = class extends Patcher { + async patch() { + if (!this.plugin.settings.getSetting("canvasMetadataCompatibilityEnabled")) return; + if (!this.plugin.app.viewRegistry.viewByType["file-properties"]) return; + await Patcher.waitForViewRequest(this.plugin, "file-properties", (view) => { + Patcher.patchPrototype(this.plugin, view, { + isSupportedFile: Patcher.OverrideExisting((next) => function(file) { + if ((file == null ? void 0 : file.extension) === "canvas") return true; + return next.call(this, file); + }), + updateFrontmatter: Patcher.OverrideExisting((next) => function(file, content) { + var _a, _b, _c; + if ((file == null ? void 0 : file.extension) === "canvas") { + let frontmatter; + try { + frontmatter = (_c = (_b = (_a = JSON.parse(content)) == null ? void 0 : _a.metadata) == null ? void 0 : _b.frontmatter) != null ? _c : {}; + } catch (e) { + frontmatter = {}; + } + this.rawFrontmatter = JSON.stringify(frontmatter, null, 2); + this.frontmatter = frontmatter; + return frontmatter; + } + return next.call(this, file, content); + }), + saveFrontmatter: Patcher.OverrideExisting((next) => function(frontmatter) { + var _a; + if (((_a = this.file) == null ? void 0 : _a.extension) === "canvas") { + if (this.file !== this.modifyingFile) return; + this.app.vault.process(this.file, (data) => { + const content = JSON.parse(data); + if (content == null ? void 0 : content.metadata) content.metadata.frontmatter = frontmatter; + return JSON.stringify(content, null, 2); + }); + return; + } + return next.call(this, frontmatter); + }) + }); + }); + } +}; + +// src/patchers/search-patcher.ts +var SearchPatcher = class extends Patcher { + async patch() { + if (!this.plugin.settings.getSetting("canvasMetadataCompatibilityEnabled")) return; + const that = this; + await Patcher.waitForViewRequest(this.plugin, "search", (view) => { + const uninstallers = []; + Patcher.patchThisAndPrototype(this.plugin, view, { + startSearch: (next) => function(...args) { + const result = next.call(this, ...args); + if (this.searchQuery) { + that.patchSearchQuery(this.searchQuery); + uninstallers.forEach((uninstall) => uninstall()); + } + return result; + } + }, uninstallers); + }); + } + patchSearchQuery(searchQuery) { + Patcher.patchThisAndPrototype(this.plugin, searchQuery, { + _match: Patcher.OverrideExisting((next) => function(data) { + var _a, _b; + const isCanvas = (_b = (_a = data.strings.filepath) == null ? void 0 : _a.endsWith(".canvas")) != null ? _b : false; + if (isCanvas && !data.cache) + data.cache = this.app.metadataCache.getCache(data.strings.filepath); + return next.call(this, data); + }) + }); + } +}; + +// src/patchers/search-command-patcher.ts +var import_obsidian10 = require("obsidian"); +var SearchCommandPatcher = class extends Patcher { + async patch() { + if (!this.plugin.settings.getSetting("nativeFileSearchEnabled")) return; + const that = this; + Patcher.patch(this.plugin, this.plugin.app.commands.commands["editor:open-search"], { + checkCallback: Patcher.OverrideExisting((next) => function(checking) { + if (that.plugin.app.workspace.activeEditor) return next.call(this, checking); + const activeCanvasView = that.plugin.getCurrentCanvasView(); + if (!activeCanvasView) return next.call(this, checking); + if (checking) return true; + if (!activeCanvasView.canvas.searchEl) new CanvasSearchView(activeCanvasView); + return true; + }) + }); + } +}; +var CanvasSearchView = class { + constructor(view) { + this.searchMatches = []; + this.matchIndex = 0; + this.view = view; + this.createSearchView(); + } + createSearchView() { + this.containerEl = document.createElement("div"); + this.containerEl.className = "document-search-container"; + const documentSearch = document.createElement("div"); + documentSearch.className = "document-search"; + this.containerEl.appendChild(documentSearch); + const searchInputContainer = document.createElement("div"); + searchInputContainer.className = "search-input-container document-search-input"; + documentSearch.appendChild(searchInputContainer); + this.searchInput = document.createElement("input"); + this.searchInput.type = "text"; + this.searchInput.placeholder = "Find..."; + this.searchInput.addEventListener("keydown", (e) => this.onKeyDown(e)); + this.searchInput.addEventListener("input", () => this.onInput()); + searchInputContainer.appendChild(this.searchInput); + this.searchCount = document.createElement("div"); + this.searchCount.className = "document-search-count"; + this.searchCount.style.display = "none"; + this.searchCount.textContent = "0 / 0"; + searchInputContainer.appendChild(this.searchCount); + const documentSearchButtons = document.createElement("div"); + documentSearchButtons.className = "document-search-buttons"; + documentSearch.appendChild(documentSearchButtons); + const previousButton = document.createElement("button"); + previousButton.className = "clickable-icon document-search-button"; + previousButton.setAttribute("aria-label", "Previous\nShift + F3"); + previousButton.setAttribute("data-tooltip-position", "top"); + (0, import_obsidian10.setIcon)(previousButton, "arrow-up"); + previousButton.addEventListener("click", () => this.changeMatch(this.matchIndex - 1)); + documentSearchButtons.appendChild(previousButton); + const nextButton = document.createElement("button"); + nextButton.className = "clickable-icon document-search-button"; + nextButton.setAttribute("aria-label", "Next\nF3"); + nextButton.setAttribute("data-tooltip-position", "top"); + (0, import_obsidian10.setIcon)(nextButton, "arrow-down"); + nextButton.addEventListener("click", () => this.changeMatch(this.matchIndex + 1)); + documentSearchButtons.appendChild(nextButton); + const closeButton = document.createElement("button"); + closeButton.className = "clickable-icon document-search-close-button"; + closeButton.setAttribute("aria-label", "Exit search"); + closeButton.setAttribute("data-tooltip-position", "top"); + (0, import_obsidian10.setIcon)(closeButton, "x"); + closeButton.addEventListener("click", () => this.close()); + documentSearch.appendChild(closeButton); + this.view.canvas.wrapperEl.appendChild(this.containerEl); + this.view.canvas.searchEl = this.containerEl; + this.searchInput.focus(); + } + onKeyDown(e) { + if (e.key === "Enter" || e.key === "F3") + this.changeMatch(this.matchIndex + (e.shiftKey ? -1 : 1)); + else if (e.key === "Escape") + this.close(); + } + onInput() { + const hasQuery = this.searchInput.value.length > 0; + this.searchCount.style.display = hasQuery ? "block" : "none"; + if (!hasQuery) this.searchMatches = []; + else { + this.searchMatches = Array.from(this.view.canvas.nodes.values()).map((node) => { + const nodeData = node.getData(); + let content = void 0; + if (nodeData.type === "text") content = nodeData.text; + else if (nodeData.type === "group") content = nodeData.label; + else if (nodeData.type === "file") content = node.child.data; + if (!content) return null; + const matches = []; + const regex = new RegExp(this.searchInput.value, "gi"); + let match; + while ((match = regex.exec(content)) !== null) { + matches.push([match.index, match.index + match[0].length]); + } + return { nodeId: node.id, content, matches }; + }).filter((match) => match && match.matches.length > 0); + } + this.changeMatch(0); + } + changeMatch(index) { + if (this.searchMatches.length === 0) this.matchIndex = -1; + else { + if (index < 0) index += this.searchMatches.length; + this.matchIndex = index % this.searchMatches.length; + } + const match = this.searchMatches[this.matchIndex]; + if (match) this.goToMatch(match); + this.searchCount.textContent = `${this.matchIndex + 1} / ${this.searchMatches.length}`; + } + goToMatch(match) { + this.view.setEphemeralState({ match }); + } + close() { + this.containerEl.remove(); + this.view.canvas.searchEl = void 0; + } +}; + +// src/canvas-extensions/metadata-canvas-extension.ts +var import_obsidian11 = require("obsidian"); +var MetadataCanvasExtension = class extends CanvasExtension { + constructor() { + super(...arguments); + this.canvasCssclassesCache = /* @__PURE__ */ new Map(); + } + isEnabled() { + return true; + } + init() { + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:canvas-changed", + (canvas) => this.onCanvasChanged(canvas) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:canvas-metadata-changed", + (canvas) => this.onMetadataChanged(canvas) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:canvas-view-unloaded:before", + (view) => this.onCanvasViewUnloaded(view) + )); + } + onCanvasChanged(canvas) { + var _a; + const metadata = (_a = canvas.data) == null ? void 0 : _a.metadata; + if (!metadata || metadata.version !== CURRENT_SPEC_VERSION) + return new import_obsidian11.Notice("Metadata node not found or version mismatch. Should have been migrated (but wasn't)."); + const that = this; + const validator = { + get(target, key) { + if (typeof target[key] === "object" && target[key] !== null) + return new Proxy(target[key], validator); + else return target[key]; + }, + set(target, key, value) { + target[key] = value; + that.plugin.app.workspace.trigger("advanced-canvas:canvas-metadata-changed", canvas); + canvas.requestSave(); + return true; + } + }; + canvas.metadata = new Proxy(metadata, validator); + this.plugin.app.workspace.trigger("advanced-canvas:canvas-metadata-changed", canvas); + } + onMetadataChanged(canvas) { + var _a, _b, _c; + const oldCssClasses = this.canvasCssclassesCache.get(canvas.view); + if (oldCssClasses) canvas.wrapperEl.classList.remove(...oldCssClasses); + const currentClasses = (_c = (_b = (_a = canvas.metadata) == null ? void 0 : _a.frontmatter) == null ? void 0 : _b.cssclasses) != null ? _c : []; + this.canvasCssclassesCache.set(canvas.view, currentClasses); + if (currentClasses.length > 0) canvas.wrapperEl.classList.add(...currentClasses); + } + onCanvasViewUnloaded(view) { + this.canvasCssclassesCache.delete(view); + } +}; + +// src/utils/modal-helper.ts +var import_obsidian12 = require("obsidian"); +var AbstractSelectionModal = class extends import_obsidian12.FuzzySuggestModal { + constructor(app, placeholder, suggestions) { + super(app); + this.suggestions = suggestions; + this.setPlaceholder(placeholder); + this.setInstructions([{ + command: "\u2191\u2193", + purpose: "to navigate" + }, { + command: "esc", + purpose: "to dismiss" + }]); + } + getItems() { + return this.suggestions; + } + getItemText(item) { + return item; + } + onChooseItem(item, evt) { + } + awaitInput() { + return new Promise((resolve, _reject) => { + this.onChooseItem = (item) => { + resolve(item); + }; + this.open(); + }); + } +}; +var FileNameModal = class extends import_obsidian12.SuggestModal { + constructor(app, parentPath, fileExtension) { + super(app); + this.parentPath = parentPath.replace(/^\//, "").replace(/\/$/, ""); + this.fileExtension = fileExtension; + } + getSuggestions(query) { + const queryWithoutExtension = query.replace(new RegExp(`\\.${this.fileExtension}$`), ""); + if (queryWithoutExtension === "") return []; + const queryWithExtension = queryWithoutExtension + "." + this.fileExtension; + const suggestions = [queryWithExtension]; + if (this.parentPath.length > 0) suggestions.splice(0, 0, `${this.parentPath}/${queryWithExtension}`); + return suggestions.filter((s) => this.app.vault.getAbstractFileByPath(s) === null); + } + renderSuggestion(text, el) { + el.setText(text); + } + onChooseSuggestion(_text, _evt) { + } + awaitInput() { + return new Promise((resolve, _reject) => { + this.onChooseSuggestion = (text) => { + resolve(text); + }; + this.open(); + }); + } +}; +var FileSelectModal = class extends import_obsidian12.SuggestModal { + constructor(app, extensionsRegex, suggestNewFile = false) { + super(app); + this.files = this.app.vault.getFiles().map((file) => file.path).filter((path) => { + var _a; + return (_a = FilepathHelper.extension(path)) == null ? void 0 : _a.match(extensionsRegex != null ? extensionsRegex : /.*/); + }); + this.suggestNewFile = suggestNewFile; + this.setPlaceholder("Type to search..."); + this.setInstructions([{ + command: "\u2191\u2193", + purpose: "to navigate" + }, { + command: "\u21B5", + purpose: "to open" + }, { + command: "shift \u21B5", + purpose: "to create" + }, { + command: "esc", + purpose: "to dismiss" + }]); + this.scope.register(["Shift"], "Enter", (e) => { + this.onChooseSuggestion(this.inputEl.value, e); + this.close(); + }); + } + getSuggestions(query) { + const suggestions = this.files.filter((path) => path.toLowerCase().includes(query.toLowerCase())); + if (suggestions.length === 0 && this.suggestNewFile) suggestions.push(query); + return suggestions; + } + renderSuggestion(path, el) { + const simplifiedPath = path.replace(/\.md$/, ""); + el.setText(simplifiedPath); + } + onChooseSuggestion(_path, _evt) { + } + awaitInput() { + return new Promise((resolve, _reject) => { + this.onChooseSuggestion = (path, _evt) => { + const file = this.app.vault.getAbstractFileByPath(path); + if (file instanceof import_obsidian12.TFile) + return resolve(file); + if (!this.suggestNewFile) return; + if (FilepathHelper.extension(path) === void 0) path += ".md"; + const newFile = this.app.vault.create(path, ""); + resolve(newFile); + }; + this.open(); + }); + } +}; + +// src/canvas-extensions/node-ratio-canvas-extension.ts +var NodeRatioCanvasExtension = class extends CanvasExtension { + isEnabled() { + return true; + } + init() { + this.plugin.registerEvent(this.plugin.app.workspace.on( + "canvas:node-menu", + (menu, node) => this.onNodeMenu(menu, node) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-resized", + (canvas, node) => this.onNodeResized(canvas, node) + )); + } + onNodeMenu(menu, node) { + if (!this.plugin.settings.getSetting("aspectRatioControlFeatureEnabled")) return; + menu.addItem((item) => { + item.setTitle("Set Aspect Ratio").setIcon("aspect-ratio").onClick(async () => { + const NO_RATIO = "No ratio enforcement"; + const newRatioString = await new AbstractSelectionModal(this.plugin.app, "Enter aspect ratio (width:height)", ["16:9", "4:3", "3:2", "1:1", NO_RATIO]).awaitInput(); + const nodeData = node.getData(); + if (newRatioString === NO_RATIO) { + node.setData({ + ...nodeData, + ratio: void 0 + }); + return; + } + const [width, height] = newRatioString.split(":").map(Number); + if (width && height) { + node.setData({ + ...nodeData, + ratio: width / height + }); + node.setData({ + ...node.getData(), + width: nodeData.height * (width / height) + }); + } + }); + }); + } + onNodeResized(_canvas, node) { + const nodeData = node.getData(); + if (!nodeData.ratio) return; + const nodeBBox = node.getBBox(); + const nodeSize = { + width: nodeBBox.maxX - nodeBBox.minX, + height: nodeBBox.maxY - nodeBBox.minY + }; + const nodeAspectRatio = nodeSize.width / nodeSize.height; + if (nodeAspectRatio < nodeData.ratio) + nodeSize.width = nodeSize.height * nodeData.ratio; + else nodeSize.height = nodeSize.width / nodeData.ratio; + node.setData({ + ...nodeData, + width: nodeSize.width, + height: nodeSize.height + }); + } +}; + +// src/canvas-extensions/group-canvas-extension.ts +var GROUP_NODE_SIZE = { width: 300, height: 300 }; +var GROUP_NODE_PADDING = 20; +var GroupCanvasExtension = class extends CanvasExtension { + isEnabled() { + return true; + } + init() { + this.plugin.addCommand({ + id: "create-group-around-selection", + name: "Group selected nodes", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (canvas) => canvas.selection.size > 0, + (canvas) => this.createGroupAroundSelection(canvas) + ) + }); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:canvas-changed", + (canvas) => { + CanvasHelper.addCardMenuOption( + canvas, + CanvasHelper.createCardMenuOption( + canvas, + { + id: "create-group", + label: "Drag to add group", + icon: "group" + }, + () => GROUP_NODE_SIZE, + (canvas2, pos) => { + canvas2.createGroupNode({ + pos, + size: GROUP_NODE_SIZE + }); + } + ) + ); + } + )); + } + createGroupAroundSelection(canvas) { + const bbox = BBoxHelper.combineBBoxes( + Array.from(canvas.selection.values()).map((e) => e.getBBox()) + ); + const paddedBBox = BBoxHelper.enlargeBBox(bbox, GROUP_NODE_PADDING); + canvas.createGroupNode({ + pos: { x: paddedBBox.minX, y: paddedBBox.minY }, + size: { + width: paddedBBox.maxX - paddedBBox.minX, + height: paddedBBox.maxY - paddedBBox.minY + } + }); + } +}; + +// src/canvas-extensions/presentation-canvas-extension.ts +var import_obsidian13 = require("obsidian"); +var START_SLIDE_NAME = "Start Slide"; +var DEFAULT_SLIDE_NAME = "New Slide"; +var PresentationCanvasExtension = class extends CanvasExtension { + constructor() { + super(...arguments); + this.savedViewport = null; + this.isPresentationMode = false; + this.visitedNodeIds = []; + this.fullscreenModalObserver = null; + this.presentationUsesFullscreen = false; + } + isEnabled() { + return "presentationFeatureEnabled"; + } + init() { + this.plugin.registerEvent(this.plugin.app.workspace.on( + "canvas:selection-menu", + (menu, canvas) => { + menu.addItem( + (item) => item.setTitle("Wrap in slide").setIcon("gallery-vertical").onClick(() => this.addSlide( + canvas, + void 0, + BBoxHelper.enlargeBBox(BBoxHelper.combineBBoxes( + [...canvas.selection.values()].map((element) => element.getBBox()) + ), this.plugin.settings.getSetting("wrapInSlidePadding")) + )) + ); + } + )); + this.plugin.addCommand({ + id: "create-new-slide", + name: "Create new slide", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (canvas) => !canvas.readonly && !this.isPresentationMode, + (canvas) => this.addSlide(canvas) + ) + }); + this.plugin.addCommand({ + id: "set-start-node", + name: "Set start node", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (canvas) => !canvas.readonly && !this.isPresentationMode && canvas.getSelectionData().nodes.length === 1, + (canvas) => this.setStartNode(canvas, canvas.nodes.get(canvas.getSelectionData().nodes[0].id)) + ) + }); + this.plugin.addCommand({ + id: "start-presentation", + name: "Start presentation", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (_canvas) => !this.isPresentationMode, + (canvas) => this.startPresentation(canvas) + ) + }); + this.plugin.addCommand({ + id: "continue-presentation", + name: "Continue presentation", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (_canvas) => !this.isPresentationMode, + (canvas) => this.startPresentation(canvas, true) + ) + }); + this.plugin.addCommand({ + id: "end-presentation", + name: "End presentation", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (_canvas) => this.isPresentationMode, + (canvas) => this.endPresentation(canvas) + ) + }); + this.plugin.addCommand({ + id: "previous-node", + name: "Previous node", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (_canvas) => this.isPresentationMode, + (canvas) => this.previousNode(canvas) + ) + }); + this.plugin.addCommand({ + id: "next-node", + name: "Next node", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (_canvas) => this.isPresentationMode, + (canvas) => this.nextNode(canvas) + ) + }); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:canvas-changed", + (canvas) => this.onCanvasChanged(canvas) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:popup-menu-created", + (canvas) => this.onPopupMenuCreated(canvas) + )); + } + onCanvasChanged(canvas) { + CanvasHelper.addCardMenuOption( + canvas, + CanvasHelper.createCardMenuOption( + canvas, + { + id: "new-slide", + label: "Drag to add slide", + icon: "gallery-vertical" + }, + () => this.getDefaultSlideSize(), + (canvas2, pos) => this.addSlide(canvas2, pos) + ) + ); + } + onPopupMenuCreated(canvas) { + if (!this.plugin.settings.getSetting("showSetStartNodeInPopup")) return; + const selectedNodesData = canvas.getSelectionData().nodes; + if (canvas.readonly || selectedNodesData.length !== 1 || canvas.selection.size > 1) return; + const selectedNode = canvas.nodes.get(selectedNodesData[0].id); + if (!selectedNode) return; + CanvasHelper.addPopupMenuOption( + canvas, + CanvasHelper.createPopupMenuOption({ + id: "start-node", + label: "Set as start slide", + icon: "play", + callback: () => this.setStartNode(canvas, selectedNode) + }) + ); + } + setStartNode(canvas, node) { + if (!node) return; + canvas.metadata["startNode"] = node.getData().id; + } + getDefaultSlideSize() { + const slideSize = this.plugin.settings.getSetting("defaultSlideDimensions"); + return { width: slideSize[0], height: slideSize[1] }; + } + getSlideAspectRatio() { + const slideSize = this.getDefaultSlideSize(); + return slideSize.width / slideSize.height; + } + addSlide(canvas, pos, bbox) { + const isStartNode = canvas.metadata["startNode"] === void 0; + const slideSize = this.getDefaultSlideSize(); + const slideAspectRatio = this.getSlideAspectRatio(); + if (bbox) { + const bboxWidth = bbox.maxX - bbox.minX; + const bboxHeight = bbox.maxY - bbox.minY; + if (bboxWidth / bboxHeight > slideAspectRatio) { + slideSize.width = bboxWidth; + slideSize.height = bboxWidth / slideAspectRatio; + } else { + slideSize.height = bboxHeight; + slideSize.width = bboxHeight * slideAspectRatio; + } + pos = { + x: bbox.minX, + y: bbox.minY + }; + } + if (!pos) pos = CanvasHelper.getCenterCoordinates(canvas, this.getDefaultSlideSize()); + const groupNode = canvas.createGroupNode({ + pos, + size: slideSize, + label: isStartNode ? START_SLIDE_NAME : DEFAULT_SLIDE_NAME, + focus: false + }); + groupNode.setData({ + ...groupNode.getData(), + ratio: slideAspectRatio + }); + if (isStartNode) canvas.metadata["startNode"] = groupNode.getData().id; + } + async animateNodeTransition(canvas, fromNode, toNode) { + const removePadding = this.plugin.settings.getSetting("zoomToSlideWithoutPadding"); + const animationDurationMs = this.plugin.settings.getSetting("slideTransitionAnimationDuration") * 1e3; + const toNodeBBox = CanvasHelper.getSmallestAllowedZoomBBox(canvas, toNode.getBBox()); + const toNodeBBoxPadded = removePadding ? toNodeBBox : BBoxHelper.enlargeBBox(toNodeBBox, 50); + console.log({ toNodeBBox, toNodeBBoxPadded }); + if (animationDurationMs > 0 && fromNode) { + const animationIntensity = this.plugin.settings.getSetting("slideTransitionAnimationIntensity"); + const fromNodeBBox = CanvasHelper.getSmallestAllowedZoomBBox(canvas, fromNode.getBBox()); + const fromNodeBBoxPadded = removePadding ? fromNodeBBox : BBoxHelper.enlargeBBox(fromNodeBBox, 50); + const currentNodeBBoxEnlarged = BBoxHelper.scaleBBox(fromNodeBBoxPadded, animationIntensity); + canvas.zoomToRealBbox(currentNodeBBoxEnlarged); + await sleep(animationDurationMs / 2); + if (fromNode.getData().id !== toNode.getData().id) { + const nextNodeBBoxEnlarged = BBoxHelper.scaleBBox(toNodeBBoxPadded, animationIntensity); + canvas.zoomToRealBbox(nextNodeBBoxEnlarged); + await sleep(animationDurationMs / 2); + } + } + canvas.zoomToRealBbox(toNodeBBoxPadded); + } + async startPresentation(canvas, tryContinue = false) { + if (!tryContinue || this.visitedNodeIds.length === 0) { + const startNode2 = canvas.metadata["startNode"] && canvas.nodes.get(canvas.metadata["startNode"]); + if (!startNode2) { + new import_obsidian13.Notice("No start node found. Please mark a node as a start node trough the popup menu."); + return; + } + this.visitedNodeIds = [startNode2.getData().id]; + } + this.savedViewport = { + x: canvas.tx, + y: canvas.ty, + zoom: canvas.tZoom + }; + const shouldEnterFullscreen = this.plugin.settings.getSetting("fullscreenPresentationEnabled"); + this.presentationUsesFullscreen = shouldEnterFullscreen; + canvas.wrapperEl.focus(); + canvas.wrapperEl.classList.add("presentation-mode"); + if (shouldEnterFullscreen) { + try { + await canvas.wrapperEl.requestFullscreen(); + } catch (e) { + this.presentationUsesFullscreen = false; + } + } + canvas.setReadonly(true); + if (this.plugin.settings.getSetting("useUnclampedZoomWhilePresenting")) + canvas.screenshotting = true; + canvas.wrapperEl.onkeydown = (e) => { + if (e.key === "Escape") { + e.preventDefault(); + e.stopPropagation(); + this.endPresentation(canvas); + return; + } + if (this.plugin.settings.getSetting("useArrowKeysToChangeSlides")) { + if (e.key === "ArrowRight") this.nextNode(canvas); + else if (e.key === "ArrowLeft") this.previousNode(canvas); + } + if (this.plugin.settings.getSetting("usePgUpPgDownKeysToChangeSlides")) { + if (e.key === "PageDown") this.nextNode(canvas); + else if (e.key === "PageUp") this.previousNode(canvas); + } + }; + if (this.presentationUsesFullscreen) { + this.fullscreenModalObserver = new MutationObserver((mutationRecords) => { + mutationRecords.forEach((mutationRecord) => { + mutationRecord.addedNodes.forEach((node) => { + var _a; + document.body.removeChild(node); + (_a = document.fullscreenElement) == null ? void 0 : _a.appendChild(node); + }); + }); + const inputField = document.querySelector(".prompt-input"); + if (inputField) inputField.focus(); + }); + this.fullscreenModalObserver.observe(document.body, { childList: true }); + canvas.wrapperEl.onfullscreenchange = (_e) => { + if (document.fullscreenElement) return; + this.endPresentation(canvas); + }; + } + this.isPresentationMode = true; + if (this.presentationUsesFullscreen) + await sleep(500); + const startNodeId = this.visitedNodeIds.first(); + if (!startNodeId) return; + const startNode = canvas.nodes.get(startNodeId); + if (!startNode) return; + this.animateNodeTransition(canvas, void 0, startNode); + } + endPresentation(canvas) { + var _a; + if (!this.isPresentationMode) return; + if (this.presentationUsesFullscreen) { + (_a = this.fullscreenModalObserver) == null ? void 0 : _a.disconnect(); + this.fullscreenModalObserver = null; + canvas.wrapperEl.onfullscreenchange = null; + if (document.fullscreenElement) document.exitFullscreen(); + } + canvas.wrapperEl.onkeydown = null; + canvas.setReadonly(false); + if (this.plugin.settings.getSetting("useUnclampedZoomWhilePresenting")) + canvas.screenshotting = false; + canvas.wrapperEl.classList.remove("presentation-mode"); + if (this.plugin.settings.getSetting("resetViewportOnPresentationEnd")) + canvas.setViewport(this.savedViewport.x, this.savedViewport.y, this.savedViewport.zoom); + this.isPresentationMode = false; + this.presentationUsesFullscreen = false; + } + nextNode(canvas) { + var _a; + const fromNodeId = this.visitedNodeIds.last(); + if (!fromNodeId) return; + const fromNode = canvas.nodes.get(fromNodeId); + if (!fromNode) return; + const outgoingEdges = canvas.getEdgesForNode(fromNode).filter((edge) => edge.from.node.getData().id === fromNodeId); + let toNode = (_a = outgoingEdges.first()) == null ? void 0 : _a.to.node; + if (outgoingEdges.length > 1) { + const sortedEdges = outgoingEdges.sort((a, b) => { + if (!a.label) return 1; + if (!b.label) return -1; + return a.label.localeCompare(b.label); + }); + const traversedEdgesCount = this.visitedNodeIds.filter((visitedNodeId) => visitedNodeId === fromNodeId).length - 1; + const nextEdge = sortedEdges[traversedEdgesCount]; + toNode = nextEdge.to.node; + } + if (toNode) { + this.visitedNodeIds.push(toNode.getData().id); + this.animateNodeTransition(canvas, fromNode, toNode); + } else { + this.animateNodeTransition(canvas, fromNode, fromNode); + } + } + previousNode(canvas) { + const fromNodeId = this.visitedNodeIds.pop(); + if (!fromNodeId) return; + const fromNode = canvas.nodes.get(fromNodeId); + if (!fromNode) return; + const toNodeId = this.visitedNodeIds.last(); + let toNode = toNodeId ? canvas.nodes.get(toNodeId) : null; + if (!toNode) { + toNode = fromNode; + this.visitedNodeIds.push(fromNodeId); + } + this.animateNodeTransition(canvas, fromNode, toNode); + } +}; + +// src/canvas-extensions/z-ordering-canvas-extension.ts +var ZOrderingCanvasExtension = class extends CanvasExtension { + isEnabled() { + return "zOrderingControlFeatureEnabled"; + } + init() { + this.plugin.registerEvent(this.plugin.app.workspace.on( + "canvas:node-menu", + (menu, node) => this.nodeContextMenu(node, menu) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "canvas:selection-menu", + (menu, canvas) => this.selectionContextMenu(canvas, menu) + )); + } + nodeContextMenu(node, menu) { + this.addZOrderingContextMenuItems(node.canvas, [node], menu); + } + selectionContextMenu(canvas, menu) { + const selectedNodes = canvas.getSelectionData().nodes.map((nodeData) => canvas.nodes.get(nodeData.id)).filter((node) => node !== void 0); + this.addZOrderingContextMenuItems(canvas, selectedNodes, menu); + } + addZOrderingContextMenuItems(canvas, nodes, menu) { + menu.addSeparator(); + if (this.plugin.settings.getSetting("zOrderingControlShowOneLayerShiftOptions") && nodes.length === 1) { + menu.addItem((item) => { + item.setTitle("Move one layer forward"); + item.setIcon("arrow-up"); + item.onClick(() => this.moveOneLayer(canvas, nodes.first(), true)); + }); + menu.addItem((item) => { + item.setTitle("Move one layer backward"); + item.setIcon("arrow-down"); + item.onClick(() => this.moveOneLayer(canvas, nodes.first(), false)); + }); + } + menu.addItem((item) => { + item.setTitle("Bring to Front"); + item.setIcon("bring-to-front"); + item.onClick(() => this.moveMaxLayers(canvas, nodes, true)); + }); + menu.addItem((item) => { + item.setTitle("Send to Back"); + item.setIcon("send-to-back"); + item.onClick(() => this.moveMaxLayers(canvas, nodes, false)); + }); + if (nodes.some((node) => node.getData().zIndex !== void 0)) { + menu.addItem((item) => { + item.setTitle("Remove persistent z-index"); + item.setIcon("pin-off"); + item.onClick(() => this.removePersistentZIndexes(canvas, nodes)); + }); + } + menu.addSeparator(); + } + moveOneLayer(canvas, selectedNode, forward) { + const selectedNodeBBox = selectedNode.getBBox(); + const collidingNodes = [...canvas.nodes.values()].filter((node) => BBoxHelper.isColliding(selectedNodeBBox, node.getBBox())).filter((node) => node !== selectedNode); + const nearestZIndexNode = collidingNodes.sort((a, b) => forward ? a.zIndex - b.zIndex : b.zIndex - a.zIndex).filter((node) => forward ? node.zIndex > selectedNode.zIndex : node.zIndex < selectedNode.zIndex).first(); + if (nearestZIndexNode === void 0) return; + const targetZIndex = nearestZIndexNode.zIndex; + this.setNodesZIndex([nearestZIndexNode], selectedNode.zIndex); + this.setNodesZIndex([selectedNode], targetZIndex); + } + moveMaxLayers(canvas, selectedNodes, forward) { + const targetZIndex = forward ? Math.max(...this.getAllZIndexes(canvas)) + 1 : Math.min(...this.getAllZIndexes(canvas)) - selectedNodes.length; + this.setNodesZIndex(selectedNodes, targetZIndex); + } + removePersistentZIndexes(_canvas, nodes) { + for (const node of nodes) node.setZIndex(void 0); + } + setNodesZIndex(nodes, zIndex) { + const sortedNodes = nodes.sort((a, b) => a.zIndex - b.zIndex); + for (let i = 0; i < sortedNodes.length; i++) { + const node = sortedNodes[i]; + const finalZIndex = zIndex + i; + node.setZIndex(finalZIndex); + } + } + getAllZIndexes(canvas) { + return [...canvas.nodes.values()].map((n) => n.zIndex); + } +}; + +// src/canvas-extensions/better-readonly-canvas-extension.ts +var BetterReadonlyCanvasExtension = class extends CanvasExtension { + constructor() { + super(...arguments); + this.isMovingToBBox = false; + } + isEnabled() { + return "betterReadonlyEnabled"; + } + init() { + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:popup-menu-created", + (canvas) => this.updatePopupMenu(canvas) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:viewport-changed:before", + (canvas) => this.onBeforeViewPortChanged(canvas) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:zoom-to-bbox:before", + () => this.isMovingToBBox = true + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:readonly-changed", + (canvas, _readonly) => { + this.updatePopupMenu(canvas); + this.updateLockedZoom(canvas); + this.updateLockedPan(canvas); + } + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:canvas-changed", + (canvas) => this.addQuickSettings(canvas) + )); + } + onBeforeViewPortChanged(canvas) { + var _a, _b, _c, _d, _e, _f; + if (this.isMovingToBBox) { + this.isMovingToBBox = false; + this.updateLockedZoom(canvas); + this.updateLockedPan(canvas); + return; + } + if (!canvas.readonly) return; + if (this.plugin.settings.getSetting("disableZoom")) { + canvas.zoom = (_a = canvas.lockedZoom) != null ? _a : canvas.zoom; + canvas.tZoom = (_b = canvas.lockedZoom) != null ? _b : canvas.tZoom; + } + if (this.plugin.settings.getSetting("disablePan")) { + canvas.x = (_c = canvas.lockedX) != null ? _c : canvas.x; + canvas.tx = (_d = canvas.lockedX) != null ? _d : canvas.tx; + canvas.y = (_e = canvas.lockedY) != null ? _e : canvas.y; + canvas.ty = (_f = canvas.lockedY) != null ? _f : canvas.ty; + } + } + addQuickSettings(canvas) { + var _a; + const settingsContainer = (_a = canvas.quickSettingsButton) == null ? void 0 : _a.parentElement; + if (!settingsContainer) return; + CanvasHelper.addControlMenuButton( + settingsContainer, + this.createToggle({ + id: "disable-node-popup", + label: "Disable node popup", + icon: "arrow-up-right-from-circle", + callback: () => this.updatePopupMenu(canvas) + }, "disableNodePopup") + ); + CanvasHelper.addControlMenuButton( + settingsContainer, + this.createToggle({ + id: "disable-zoom", + label: "Disable zoom", + icon: "zoom-in", + callback: () => this.updateLockedZoom(canvas) + }, "disableZoom") + ); + CanvasHelper.addControlMenuButton( + settingsContainer, + this.createToggle({ + id: "disable-pan", + label: "Disable pan", + icon: "move", + callback: () => this.updateLockedPan(canvas) + }, "disablePan") + ); + } + createToggle(menuOption, settingKey) { + const toggle = CanvasHelper.createControlMenuButton({ + ...menuOption, + callback: () => (async () => { + var _a; + const newValue = !this.plugin.settings.getSetting(settingKey); + await this.plugin.settings.setSetting({ [settingKey]: newValue }); + toggle.dataset.toggled = this.plugin.settings.getSetting(settingKey).toString(); + (_a = menuOption.callback) == null ? void 0 : _a.call(this); + })() + }); + toggle.classList.add("show-while-readonly"); + toggle.dataset.toggled = this.plugin.settings.getSetting(settingKey).toString(); + return toggle; + } + updatePopupMenu(canvas) { + const hidden = canvas.readonly && this.plugin.settings.getSetting("disableNodePopup"); + canvas.menu.menuEl.style.visibility = hidden ? "hidden" : "visible"; + } + updateLockedZoom(canvas) { + canvas.lockedZoom = canvas.tZoom; + } + updateLockedPan(canvas) { + canvas.lockedX = canvas.tx; + canvas.lockedY = canvas.ty; + } +}; + +// src/canvas-extensions/encapsulate-canvas-extension.ts +var ENCAPSULATED_FILE_NODE_SIZE = { width: 300, height: 300 }; +var EncapsulateCanvasExtension = class extends CanvasExtension { + isEnabled() { + return "canvasEncapsulationEnabled"; + } + init() { + this.plugin.addCommand({ + id: "encapsulate-selection", + name: "Encapsulate selection", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (canvas) => !canvas.readonly && canvas.selection.size > 0, + (canvas) => this.encapsulateSelection(canvas) + ) + }); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "canvas:selection-menu", + (menu, canvas) => { + menu.addItem( + (item) => item.setTitle("Encapsulate").setIcon("file-plus").onClick(() => this.encapsulateSelection(canvas)) + ); + } + )); + } + async encapsulateSelection(canvas) { + var _a, _b, _c, _d; + const selection = canvas.getSelectionData(); + const canvasSettings = this.plugin.app.internalPlugins.plugins.canvas.instance.options; + const defaultNewCanvasLocation = canvasSettings.newFileLocation; + let targetFolderPath = this.plugin.app.vault.getRoot().path; + if (defaultNewCanvasLocation === "current") targetFolderPath = (_c = (_b = (_a = canvas.view.file) == null ? void 0 : _a.parent) == null ? void 0 : _b.path) != null ? _c : targetFolderPath; + else if (defaultNewCanvasLocation === "folder") targetFolderPath = (_d = canvasSettings.newFileFolderPath) != null ? _d : targetFolderPath; + const targetFilePath = await new FileNameModal( + this.plugin.app, + targetFolderPath, + "canvas" + ).awaitInput(); + const newFileData = { nodes: selection.nodes, edges: selection.edges }; + const file = await this.plugin.app.vault.create(targetFilePath, JSON.stringify(newFileData, null, 2)); + for (const nodeData of selection.nodes) { + const node = canvas.nodes.get(nodeData.id); + if (node) canvas.removeNode(node); + } + canvas.createFileNode({ + pos: { + x: selection.center.x - ENCAPSULATED_FILE_NODE_SIZE.width / 2, + y: selection.center.y - ENCAPSULATED_FILE_NODE_SIZE.height / 2 + }, + size: ENCAPSULATED_FILE_NODE_SIZE, + file + }); + } +}; + +// src/canvas-extensions/commands-canvas-extension.ts +var import_obsidian14 = require("obsidian"); +var DIRECTIONS = ["up", "down", "left", "right"]; +var CommandsCanvasExtension = class extends CanvasExtension { + isEnabled() { + return "commandsFeatureEnabled"; + } + init() { + this.plugin.addCommand({ + id: "toggle-readonly", + name: "Toggle readonly", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (_canvas) => true, + (canvas) => canvas.setReadonly(!canvas.readonly) + ) + }); + this.plugin.addCommand({ + id: "create-text-node", + name: "Create text node", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (canvas) => !canvas.readonly, + (canvas) => this.createTextNode(canvas) + ) + }); + this.plugin.addCommand({ + id: "create-file-node", + name: "Create file node", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (canvas) => !canvas.readonly, + (canvas) => this.createFileNode(canvas) + ) + }); + this.plugin.addCommand({ + id: "select-all-edges", + name: "Select all edges", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (_canvas) => true, + (canvas) => canvas.updateSelection( + () => canvas.selection = new Set(canvas.edges.values()) + ) + ) + }); + this.plugin.addCommand({ + id: "zoom-to-selection", + name: "Zoom to selection", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (canvas) => canvas.selection.size > 0, + (canvas) => canvas.zoomToSelection() + ) + }); + this.plugin.addCommand({ + id: "zoom-to-fit", + name: "Zoom to fit", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (_canvas) => true, + (canvas) => canvas.zoomToFit() + ) + }); + for (const direction of DIRECTIONS) { + this.plugin.addCommand({ + id: `clone-node-${direction}`, + name: `Clone node ${direction}`, + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (canvas) => { + var _a; + return !canvas.readonly && canvas.selection.size === 1 && ((_a = canvas.selection.values().next().value) == null ? void 0 : _a.getData().type) === "text"; + }, + (canvas) => this.cloneNode(canvas, direction) + ) + }); + this.plugin.addCommand({ + id: `expand-node-${direction}`, + name: `Expand node ${direction}`, + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (canvas) => !canvas.readonly && canvas.selection.size === 1, + (canvas) => this.expandNode(canvas, direction) + ) + }); + this.plugin.addCommand({ + id: `navigate-${direction}`, + name: `Navigate ${direction}`, + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (canvas) => canvas.getSelectionData().nodes.length === 1, + (canvas) => this.navigate(canvas, direction) + ) + }); + } + this.plugin.addCommand({ + id: "flip-selection-horizontally", + name: "Flip selection horizontally", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (canvas) => !canvas.readonly && canvas.selection.size > 0, + (canvas) => this.flipSelection( + canvas, + true + ) + ) + }); + this.plugin.addCommand({ + id: "flip-selection-vertically", + name: "Flip selection vertically", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (canvas) => !canvas.readonly && canvas.selection.size > 0, + (canvas) => this.flipSelection(canvas, false) + ) + }); + this.plugin.addCommand({ + id: "select-connected-edges", + name: "Select connected edges", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (canvas) => canvas.selection.size > 0, + (canvas) => CanvasHelper.selectEdgesForNodes(canvas, "connected") + ) + }); + this.plugin.addCommand({ + id: "select-incoming-edges", + name: "Select incoming edges", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (canvas) => canvas.selection.size > 0, + (canvas) => CanvasHelper.selectEdgesForNodes(canvas, "incoming") + ) + }); + this.plugin.addCommand({ + id: "select-outgoing-edges", + name: "Select outgoing edges", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (canvas) => canvas.selection.size > 0, + (canvas) => CanvasHelper.selectEdgesForNodes(canvas, "outgoing") + ) + }); + this.plugin.addCommand({ + id: "swap-nodes", + name: "Swap nodes", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (canvas) => !canvas.readonly && canvas.getSelectionData().nodes.length === 2, + (canvas) => { + const selectedNodes = canvas.getSelectionData().nodes.map((nodeData) => canvas.nodes.get(nodeData.id)).filter((node) => node !== void 0); + if (selectedNodes.length !== 2) return; + const [nodeA, nodeB] = selectedNodes; + const nodeAData = nodeA.getData(); + const nodeBData = nodeB.getData(); + nodeA.setData({ ...nodeAData, x: nodeBData.x, y: nodeBData.y, width: nodeBData.width, height: nodeBData.height }); + nodeB.setData({ ...nodeBData, x: nodeAData.x, y: nodeAData.y, width: nodeAData.width, height: nodeAData.height }); + canvas.pushHistory(canvas.getData()); + } + ) + }); + this.plugin.addCommand({ + id: "copy-wikilink-to-node", + name: "Copy wikilink to node", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (canvas) => !canvas.readonly && canvas.selection.size === 1, + (canvas) => { + const file = canvas.view.file; + if (!file) return; + const nodeData = canvas.getSelectionData().nodes[0]; + if (!nodeData) return; + const wikilink = `[[${file.path}#${nodeData.id}|${file.name} (${TextHelper.toTitleCase(nodeData.type)} node)]]`; + navigator.clipboard.writeText(wikilink); + new import_obsidian14.Notice("Copied wikilink to node to clipboard.", 2e3); + } + ) + }); + this.plugin.addCommand({ + id: "pull-outgoing-links-to-canvas", + name: "Pull outgoing links to canvas", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (canvas) => !canvas.readonly, + (canvas) => { + var _a, _b, _c; + const canvasFile = canvas.view.file; + if (!canvasFile) return; + let selectedNodeIds = canvas.getSelectionData().nodes.map((node) => node.id); + if (selectedNodeIds.length === 0) selectedNodeIds = [...canvas.nodes.keys()]; + const metadata = this.plugin.app.metadataCache.getFileCache(canvasFile); + if (!metadata) return; + const outgoingLinks = /* @__PURE__ */ new Set(); + for (const nodeId of selectedNodeIds) { + let relativeFile = canvasFile; + let nodeOutgoingLinks = (_b = (_a = metadata.nodes) == null ? void 0 : _a[nodeId]) == null ? void 0 : _b.links; + if (!nodeOutgoingLinks) { + const file = (_c = canvas.nodes.get(nodeId)) == null ? void 0 : _c.file; + if (!file) continue; + const fileMetadata = this.plugin.app.metadataCache.getFileCache(file); + nodeOutgoingLinks = fileMetadata == null ? void 0 : fileMetadata.links; + relativeFile = file; + } + if (!nodeOutgoingLinks) continue; + for (const nodeOutgoingLink of nodeOutgoingLinks) { + const resolvedLink = this.plugin.app.metadataCache.getFirstLinkpathDest(nodeOutgoingLink.link, relativeFile.path); + if (!(resolvedLink instanceof import_obsidian14.TFile)) continue; + outgoingLinks.add(resolvedLink); + } + } + const existingFileNodes = /* @__PURE__ */ new Set([canvas.view.file]); + for (const node of canvas.nodes.values()) { + if (node.getData().type !== "file" || !node.file) continue; + existingFileNodes.add(node.file); + } + for (const outgoingLink of outgoingLinks) { + if (existingFileNodes.has(outgoingLink)) continue; + this.createFileNode(canvas, outgoingLink); + } + } + ) + }); + this.plugin.addCommand({ + id: "pull-backlinks-to-canvas", + name: "Pull backlinks to canvas", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (canvas) => !canvas.readonly, + (canvas) => { + const canvasFile = canvas.view.file; + if (!canvasFile) return; + const selectedNodesData = canvas.getSelectionData().nodes.map((node) => node); + const backlinks = /* @__PURE__ */ new Set(); + if (selectedNodesData.length > 0) { + for (const nodeData of selectedNodesData) { + if (nodeData.type !== "file" || !nodeData.file) continue; + const file = this.plugin.app.vault.getFileByPath(nodeData.file); + if (!file) continue; + const nodeBacklinks = this.plugin.app.metadataCache.getBacklinksForFile(file); + if (!nodeBacklinks) continue; + for (const nodeBacklink of nodeBacklinks.data.keys()) { + const resolvedLink = this.plugin.app.metadataCache.getFirstLinkpathDest(nodeBacklink, file.path); + if (!(resolvedLink instanceof import_obsidian14.TFile)) continue; + backlinks.add(resolvedLink); + } + } + } else { + const canvasBacklinks = this.plugin.app.metadataCache.getBacklinksForFile(canvasFile); + if (!canvasBacklinks) return; + for (const canvasBacklink of canvasBacklinks.data.keys()) { + const resolvedLink = this.plugin.app.metadataCache.getFirstLinkpathDest(canvasBacklink, canvasFile.path); + if (!(resolvedLink instanceof import_obsidian14.TFile)) continue; + backlinks.add(resolvedLink); + } + } + const existingFileNodes = /* @__PURE__ */ new Set([canvas.view.file]); + for (const node of canvas.nodes.values()) { + if (node.getData().type !== "file" || !node.file) continue; + existingFileNodes.add(node.file); + } + for (const backlink of backlinks) { + if (existingFileNodes.has(backlink)) continue; + this.createFileNode(canvas, backlink); + } + } + ) + }); + } + createTextNode(canvas) { + const size = canvas.config.defaultTextNodeDimensions; + const pos = CanvasHelper.getCenterCoordinates(canvas, size); + canvas.createTextNode({ pos, size }); + } + async createFileNode(canvas, file) { + const size = canvas.config.defaultFileNodeDimensions; + const pos = CanvasHelper.getCenterCoordinates(canvas, size); + file != null ? file : file = await new FileSelectModal(this.plugin.app, void 0, true).awaitInput(); + canvas.createFileNode({ pos, size, file }); + } + cloneNode(canvas, cloneDirection) { + const sourceNode = canvas.selection.values().next().value; + if (!sourceNode) return; + const sourceNodeData = sourceNode.getData(); + const nodeMargin = this.plugin.settings.getSetting("cloneNodeMargin"); + const offset = { + x: (sourceNode.width + nodeMargin) * (cloneDirection === "left" ? -1 : cloneDirection === "right" ? 1 : 0), + y: (sourceNode.height + nodeMargin) * (cloneDirection === "up" ? -1 : cloneDirection === "down" ? 1 : 0) + }; + const clonedNode = canvas.createTextNode({ + pos: { + x: sourceNode.x + offset.x, + y: sourceNode.y + offset.y + }, + size: { + width: sourceNode.width, + height: sourceNode.height + } + }); + clonedNode.setData({ + ...clonedNode.getData(), + color: sourceNodeData.color, + styleAttributes: sourceNodeData.styleAttributes + }); + if (this.plugin.settings.getSetting("zoomToClonedNode")) + canvas.zoomToBbox(clonedNode.getBBox()); + } + expandNode(canvas, expandDirection) { + const node = canvas.selection.values().next().value; + if (!node) return; + const expandNodeStepSize = this.plugin.settings.getSetting("expandNodeStepSize"); + const expand = { + x: expandDirection === "left" ? -1 : expandDirection === "right" ? 1 : 0, + y: expandDirection === "up" ? -1 : expandDirection === "down" ? 1 : 0 + }; + node.setData({ + ...node.getData(), + width: node.width + expand.x * expandNodeStepSize, + height: node.height + expand.y * expandNodeStepSize + }); + } + flipSelection(canvas, horizontally) { + const selectionData = canvas.getSelectionData(); + if (selectionData.nodes.length === 0) return; + const nodeIds = /* @__PURE__ */ new Set(); + for (const nodeData of selectionData.nodes) { + nodeIds.add(nodeData.id); + const node = canvas.nodes.get(nodeData.id); + if (!node) continue; + const newX = horizontally ? 2 * selectionData.center.x - nodeData.x - nodeData.width : nodeData.x; + const newY = horizontally ? nodeData.y : 2 * selectionData.center.y - nodeData.y - nodeData.height; + node.setData({ + ...nodeData, + x: newX, + y: newY + }); + } + for (const edge of canvas.edges.values()) { + const edgeData = edge.getData(); + let newFromSide = edgeData.fromSide; + if (nodeIds.has(edgeData.fromNode) && BBoxHelper.isHorizontal(edgeData.fromSide) === horizontally) + newFromSide = BBoxHelper.getOppositeSide(edgeData.fromSide); + let newToSide = edgeData.toSide; + if (nodeIds.has(edgeData.toNode) && BBoxHelper.isHorizontal(edgeData.toSide) === horizontally) + newToSide = BBoxHelper.getOppositeSide(edgeData.toSide); + edge.setData({ + ...edgeData, + fromSide: newFromSide, + toSide: newToSide + }); + } + canvas.pushHistory(canvas.getData()); + } + navigate(canvas, direction) { + const node = this.getNextNode(canvas, direction); + if (!node) return; + canvas.updateSelection(() => { + canvas.selection = /* @__PURE__ */ new Set([node]); + }); + } + getNextNode(canvas, direction) { + var _a; + const selectedNodeData = (_a = canvas.getSelectionData().nodes) == null ? void 0 : _a.first(); + if (!selectedNodeData) return; + const selectedNodeBBox = { + minX: selectedNodeData.x, + minY: selectedNodeData.y, + maxX: selectedNodeData.x + selectedNodeData.width, + maxY: selectedNodeData.y + selectedNodeData.height + }; + const possibleTargetNodes = Array.from(canvas.nodes.values()).filter((node) => { + const nodeData = node.getData(); + return nodeData.id !== selectedNodeData.id && (nodeData.type === "text" || nodeData.type === "file"); + }); + const closestNode = possibleTargetNodes.reduce((closestNode2, node) => { + const nodeBBox = node.getBBox(); + const isInVerticalRange = selectedNodeBBox.minY <= nodeBBox.maxY && selectedNodeBBox.maxY >= nodeBBox.minY; + const isInHorizontalRange = selectedNodeBBox.minX <= nodeBBox.maxX && selectedNodeBBox.maxX >= nodeBBox.minX; + if (["up", "down"].includes(direction) && !isInHorizontalRange) return closestNode2; + if (["left", "right"].includes(direction) && !isInVerticalRange) return closestNode2; + let distance = -1; + switch (direction) { + case "up": + distance = selectedNodeBBox.minY - nodeBBox.maxY; + break; + case "down": + distance = nodeBBox.minY - selectedNodeBBox.maxY; + break; + case "left": + distance = selectedNodeBBox.minX - nodeBBox.maxX; + break; + case "right": + distance = nodeBBox.minX - selectedNodeBBox.maxX; + break; + } + if (distance < 0) return closestNode2; + if (!closestNode2) return { node, distance }; + if (distance < closestNode2.distance) return { node, distance }; + if (distance === closestNode2.distance) { + const selectedNodeCenter = { + x: selectedNodeData.x + selectedNodeData.width / 2, + y: selectedNodeData.y + selectedNodeData.height / 2 + }; + const closestNodeCenter = { + x: closestNode2.node.x + closestNode2.node.width / 2, + y: closestNode2.node.y + closestNode2.node.height / 2 + }; + const nodeCenter = { + x: node.x + node.width / 2, + y: node.y + node.height / 2 + }; + const closestNodeDistance = Math.sqrt( + Math.pow(selectedNodeCenter.x - closestNodeCenter.x, 2) + Math.pow(selectedNodeCenter.y - closestNodeCenter.y, 2) + ); + const nodeDistance = Math.sqrt( + Math.pow(selectedNodeCenter.x - nodeCenter.x, 2) + Math.pow(selectedNodeCenter.y - nodeCenter.y, 2) + ); + if (nodeDistance < closestNodeDistance) return { node, distance }; + } + return closestNode2; + }, null); + return closestNode == null ? void 0 : closestNode.node; + } +}; + +// src/canvas-extensions/auto-resize-node-canvas-extension.ts +var AutoResizeNodeCanvasExtension = class extends CanvasExtension { + isEnabled() { + return "autoResizeNodeFeatureEnabled"; + } + init() { + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-created", + (canvas, node) => this.onNodeCreated(canvas, node) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:popup-menu-created", + (canvas) => this.onPopupMenuCreated(canvas) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-editing-state-changed", + (canvas, node, editing) => this.onNodeEditingStateChanged(canvas, node, editing) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-text-content-changed", + (canvas, node, viewUpdate) => this.onNodeTextContentChanged(canvas, node, viewUpdate.view.dom) + )); + } + isValidNodeType(nodeData) { + return nodeData.type === "text" || nodeData.type === "file" && nodeData.file.endsWith(".md"); + } + onNodeCreated(_canvas, node) { + const autoResizeNodeEnabledByDefault = this.plugin.settings.getSetting("autoResizeNodeEnabledByDefault"); + if (!autoResizeNodeEnabledByDefault) return; + const nodeData = node.getData(); + if (nodeData.type !== "text" && nodeData.type !== "file") return; + node.setData({ + ...node.getData(), + dynamicHeight: true + }); + } + onPopupMenuCreated(canvas) { + if (canvas.readonly) return; + const selectedNodes = canvas.getSelectionData().nodes.filter((nodeData) => this.isValidNodeType(nodeData)).map((nodeData) => canvas.nodes.get(nodeData.id)).filter((node) => node !== void 0); + if (selectedNodes.length === 0) return; + const autoResizeHeightEnabled = selectedNodes.some((node) => node.getData().dynamicHeight); + CanvasHelper.addPopupMenuOption( + canvas, + CanvasHelper.createPopupMenuOption({ + id: "auto-resize-height", + label: autoResizeHeightEnabled ? "Disable auto-resize" : "Enable auto-resize", + icon: autoResizeHeightEnabled ? "scan-text" : "lock", + callback: () => this.toggleAutoResizeHeightEnabled(canvas, selectedNodes, autoResizeHeightEnabled) + }) + ); + } + toggleAutoResizeHeightEnabled(canvas, nodes, autoResizeHeight) { + nodes.forEach((node) => node.setData({ + ...node.getData(), + dynamicHeight: !autoResizeHeight + })); + this.onPopupMenuCreated(canvas); + } + canBeResized(node) { + const nodeData = node.getData(); + return nodeData.dynamicHeight; + } + async onNodeEditingStateChanged(_canvas, node, editing) { + if (!this.isValidNodeType(node.getData())) return; + if (!this.canBeResized(node)) return; + await sleep(10); + if (editing) { + this.onNodeTextContentChanged(_canvas, node, node.child.editMode.cm.dom); + return; + } + const renderedMarkdownContainer = node.nodeEl.querySelector(".markdown-preview-view.markdown-rendered"); + if (!renderedMarkdownContainer) return; + renderedMarkdownContainer.style.height = "min-content"; + const newHeight = renderedMarkdownContainer.clientHeight; + renderedMarkdownContainer.style.removeProperty("height"); + this.setNodeHeight(node, newHeight); + } + async onNodeTextContentChanged(_canvas, node, dom) { + if (!this.isValidNodeType(node.getData())) return; + if (!this.canBeResized(node)) return; + const cmScroller = dom.querySelector(".cm-scroller"); + if (!cmScroller) return; + cmScroller.style.height = "min-content"; + const newHeight = cmScroller.scrollHeight; + cmScroller.style.removeProperty("height"); + this.setNodeHeight(node, newHeight); + } + setNodeHeight(node, height) { + if (height === 0) return; + const maxHeight = this.plugin.settings.getSetting("autoResizeNodeMaxHeight"); + if (maxHeight != -1 && height > maxHeight) height = maxHeight; + const nodeData = node.getData(); + height = Math.max(height, node.canvas.config.minContainerDimension); + if (this.plugin.settings.getSetting("autoResizeNodeSnapToGrid")) + height = Math.ceil(height / CanvasHelper.GRID_SIZE) * CanvasHelper.GRID_SIZE; + node.setData({ + ...nodeData, + height + }); + } +}; + +// src/canvas-extensions/portals-canvas-extension.ts +var import_obsidian15 = require("obsidian"); +var PORTAL_ID_DELIMITER = "||"; +var PORTAL_ID_PREFIX = `acportal${PORTAL_ID_DELIMITER}`; +var PORTAL_PADDING = 50; +var MIN_OPEN_PORTAL_SIZE = { width: 200, height: 200 }; +var PortalsCanvasExtension = class _PortalsCanvasExtension extends CanvasExtension { + isEnabled() { + return "portalsFeatureEnabled"; + } + init() { + this.plugin.registerEvent(this.plugin.app.vault.on("modify", (file) => { + for (const canvas of this.plugin.getCanvases()) + this.onFileModified(canvas, file); + })); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:popup-menu-created", + (canvas) => this.onPopupMenu(canvas) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-removed", + (canvas, node) => this.onNodeRemoved(canvas, node) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-moved", + (canvas, node, _keyboard) => this.onNodeMoved(canvas, node) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-resized", + (canvas, node) => this.onNodeResized(canvas, node) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:dragging-state-changed", + (canvas, startedDragging) => this.onDraggingStateChanged(canvas, startedDragging) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:containing-nodes-requested", + (canvas, bbox, nodes) => this.onContainingNodesRequested(canvas, bbox, nodes) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:edge-connection-try-dragging:before", + (canvas, edge, event, cancelRef) => this.onEdgeConnectionTryDraggingBefore(canvas, edge, event, cancelRef) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:edge-connection-dragging:after", + (canvas, edge, event, newEdge, side, previousEnds) => this.onEdgeConnectionDraggingAfter(canvas, edge, event, newEdge, side, previousEnds) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:selection-changed", + (canvas, oldSelection, updateSelection) => this.onSelectionChanged(canvas, oldSelection, updateSelection) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:data-requested", + (canvas, data) => this.onGetData(canvas, data) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:data-loaded:before", + (canvas, data, setData) => { + this.onSetData(canvas, data).then((newData) => { + if (newData.nodes.length === data.nodes.length && newData.edges.length === data.edges.length) return; + setData(newData); + }); + } + )); + } + onFileModified(canvas, file) { + const isAffected = Object.values(canvas.nodes).filter( + (nodeData) => nodeData.getData().type === "file" && nodeData.currentPortalFile === file.path + ).length > 0; + if (!isAffected) return; + canvas.setData(canvas.getData()); + canvas.history.current--; + canvas.history.data.pop(); + } + onContainingNodesRequested(_canvas, _bbox, nodes) { + const filteredNodes = nodes.filter((node) => !_PortalsCanvasExtension.isPortalElement(node.id)); + nodes.splice(0, nodes.length, ...filteredNodes); + } + onSelectionChanged(canvas, _oldSelection, updateSelection) { + updateSelection(() => { + const updatedSelection = Array.from(canvas.selection).filter((canvasElement) => !_PortalsCanvasExtension.isPortalElement(canvasElement.id)); + canvas.selection = new Set(updatedSelection); + }); + } + onDraggingStateChanged(canvas, startedDragging) { + if (!startedDragging) return; + if (!canvas.getSelectionData().nodes.some((node) => node.type === "file" && node.portal)) return; + const objectSnappingEnabled = canvas.options.snapToObjects; + if (!objectSnappingEnabled) return; + canvas.toggleObjectSnapping(false); + const dragEndEventRef = this.plugin.app.workspace.on( + "advanced-canvas:dragging-state-changed", + (canvas2, startedDragging2) => { + if (startedDragging2) return; + canvas2.toggleObjectSnapping(objectSnappingEnabled); + this.plugin.app.workspace.offref(dragEndEventRef); + } + ); + this.plugin.registerEvent(dragEndEventRef); + } + onNodeMoved(canvas, portalNode) { + const portalNodeData = portalNode.getData(); + if (portalNodeData.type !== "file" || !portalNodeData.isPortalLoaded) return; + const nestedNodes = this.getContainingNodes(canvas, portalNode); + const containingNodesBBox = CanvasHelper.getBBox(nestedNodes); + const portalOffset = { + x: portalNodeData.x - containingNodesBBox.minX + PORTAL_PADDING, + y: portalNodeData.y - containingNodesBBox.minY + PORTAL_PADDING + }; + for (const nestedNode of nestedNodes) { + const nestedNodeData = nestedNode.getData(); + nestedNode.setData({ + ...nestedNodeData, + x: nestedNodeData.x + portalOffset.x, + y: nestedNodeData.y + portalOffset.y + }); + } + } + onNodeResized(_canvas, portalNode) { + const portalNodeData = portalNode.getData(); + if (portalNodeData.type !== "file" || !portalNodeData.isPortalLoaded) return; + portalNode.setData({ + ...portalNodeData, + x: portalNode.prevX ? portalNode.prevX : portalNodeData.x, + y: portalNode.prevY ? portalNode.prevY : portalNodeData.y, + width: portalNode.prevWidth ? portalNode.prevWidth : portalNodeData.width, + height: portalNode.prevHeight ? portalNode.prevHeight : portalNodeData.height + }); + } + onNodeRemoved(canvas, portalNode) { + const portalNodeData = portalNode.getData(); + if (portalNodeData.type !== "file" || !portalNodeData.portal) return; + for (const node of this.getContainingNodes(canvas, portalNode, false)) + canvas.removeNode(node); + for (const edge of this.getContainingEdges(canvas, portalNode, false)) + canvas.removeEdge(edge); + } + onEdgeConnectionTryDraggingBefore(_canvas, edge, _event, cancelRef) { + if (!_PortalsCanvasExtension.isPortalElement(edge.id)) return; + cancelRef.value = true; + new import_obsidian15.Notice("Updating edges from portals is not supported yet."); + } + onEdgeConnectionDraggingAfter(canvas, edge, _event, _newEdge, _side, _previousEnds) { + if (_PortalsCanvasExtension.isPortalElement(edge.id)) return; + if (!_PortalsCanvasExtension.isPortalElement(edge.from.node.id) || !_PortalsCanvasExtension.isPortalElement(edge.to.node.id)) return; + canvas.removeEdge(edge); + new import_obsidian15.Notice("Creating edges with both ends in portals are not supported yet."); + } + onPopupMenu(canvas) { + if (canvas.readonly) return; + const selectedFileNodes = canvas.getSelectionData().nodes.map((nodeData) => { + var _a; + const node = canvas.nodes.get(nodeData.id); + if (!node) return null; + if (nodeData.type !== "file") return null; + if (((_a = node.file) == null ? void 0 : _a.extension) === "canvas") return node; + if (nodeData.portal) this.setPortalOpen(canvas, node, false); + return null; + }).filter((node) => node !== null); + if (selectedFileNodes.length !== 1) return; + const portalNode = selectedFileNodes.first(); + const portalNodeData = portalNode.getData(); + if (portalNodeData.portal && portalNodeData.file !== portalNode.currentPortalFile) + this.setPortalOpen(canvas, portalNode, true); + CanvasHelper.addPopupMenuOption( + canvas, + CanvasHelper.createPopupMenuOption({ + id: "toggle-portal", + label: portalNodeData.portal ? "Close portal" : "Open portal", + icon: portalNodeData.portal ? "door-open" : "door-closed", + callback: () => { + this.setPortalOpen(canvas, portalNode, !portalNodeData.portal); + this.onPopupMenu(canvas); + } + }) + ); + } + setPortalOpen(canvas, portalNode, open) { + const portalNodeData = portalNode.getData(); + portalNode.setData({ + ...portalNodeData, + portal: open + }); + portalNode.currentPortalFile = open ? portalNodeData.file : void 0; + canvas.setData(canvas.getData()); + } + // Remove all edges and nodes from portals + onGetData(_canvas, data) { + data.nodes = data.nodes.filter((nodeData) => !_PortalsCanvasExtension.isPortalElement(nodeData.id)); + for (const nodeData of data.nodes) delete nodeData.isPortalLoaded; + const portalsIdMap = new Map( + data.nodes.filter((nodeData) => nodeData.portal).map((nodeData) => [nodeData.id, nodeData]) + ); + data.edges = data.edges.filter((edgeData) => { + var _a; + if (_PortalsCanvasExtension.isPortalElement(edgeData.id)) return false; + const isFromNodeFromPortal = _PortalsCanvasExtension.getNestedIds(edgeData.fromNode).length > 1; + const isToNodeFromPortal = _PortalsCanvasExtension.getNestedIds(edgeData.toNode).length > 1; + if (!isFromNodeFromPortal && !isToNodeFromPortal) return true; + if (isFromNodeFromPortal && isToNodeFromPortal) return false; + const targetPortalId = this.getParentPortalId(isFromNodeFromPortal ? edgeData.fromNode : edgeData.toNode); + const targetPortalData = portalsIdMap.get(targetPortalId); + if (!targetPortalData) return false; + (_a = targetPortalData.interdimensionalEdges) != null ? _a : targetPortalData.interdimensionalEdges = []; + targetPortalData.interdimensionalEdges.push(edgeData); + return false; + }); + } + // Add all edges and nodes from portals + async onSetData(canvas, dataRef) { + if (!(dataRef == null ? void 0 : dataRef.nodes)) return dataRef; + const data = JSON.parse(JSON.stringify(dataRef)); + const addedData = await Promise.all(data.nodes.map((nodeData) => this.tryOpenPortal(canvas, nodeData))); + for (const newData of addedData) { + data.nodes.push(...newData.nodes); + data.edges.push(...newData.edges); + } + for (const nodeData of data.nodes) { + if (nodeData.type !== "file" || !nodeData.isPortalLoaded) continue; + const interdimensionalEdges = nodeData.interdimensionalEdges; + if (!interdimensionalEdges) continue; + for (const edge of interdimensionalEdges) data.edges.push(edge); + delete nodeData.interdimensionalEdges; + } + return data; + } + async tryOpenPortal(canvas, portalNodeData, nestedPortalFiles = /* @__PURE__ */ new Set()) { + const addedData = { nodes: [], edges: [] }; + if (portalNodeData.type !== "file" || !portalNodeData.portal) return addedData; + if (portalNodeData.file === canvas.view.file.path) return addedData; + if (nestedPortalFiles.has(portalNodeData.file)) return addedData; + nestedPortalFiles.add(portalNodeData.file); + const portalFile = this.plugin.app.vault.getAbstractFileByPath(portalNodeData.file); + if (!(portalFile instanceof import_obsidian15.TFile) || portalFile.extension !== "canvas") return addedData; + const portalFileDataString = await this.plugin.app.vault.cachedRead(portalFile); + if (portalFileDataString === "") return addedData; + const portalFileData = JSON.parse(portalFileDataString); + if (!portalFileData) return addedData; + portalNodeData.isPortalLoaded = true; + const sourceMinCoordinates = CanvasHelper.getBBox(portalFileData.nodes); + const portalOffset = { + x: portalNodeData.x - sourceMinCoordinates.minX + PORTAL_PADDING, + y: portalNodeData.y - sourceMinCoordinates.minY + PORTAL_PADDING + }; + for (const nodeDataFromPortal of portalFileData.nodes) { + let newNodeId = `${portalNodeData.id}${PORTAL_ID_DELIMITER}${nodeDataFromPortal.id}`; + if (!newNodeId.startsWith(PORTAL_ID_PREFIX)) + newNodeId = PORTAL_ID_PREFIX + newNodeId; + const addedNode = { + ...nodeDataFromPortal, + id: newNodeId, + x: nodeDataFromPortal.x + portalOffset.x, + y: nodeDataFromPortal.y + portalOffset.y + }; + addedData.nodes.push(addedNode); + const nestedNodes = await this.tryOpenPortal(canvas, addedNode, nestedPortalFiles); + addedData.nodes.push(...nestedNodes.nodes); + addedData.edges.push(...nestedNodes.edges); + } + for (const edgeDataFromPortal of portalFileData.edges) { + let newEdgeId = `${portalNodeData.id}${PORTAL_ID_DELIMITER}${edgeDataFromPortal.id}`; + if (!newEdgeId.startsWith(PORTAL_ID_PREFIX)) + newEdgeId = PORTAL_ID_PREFIX + newEdgeId; + let fromNodeId = `${portalNodeData.id}${PORTAL_ID_DELIMITER}${edgeDataFromPortal.fromNode}`; + if (!fromNodeId.startsWith(PORTAL_ID_PREFIX)) + fromNodeId = PORTAL_ID_PREFIX + fromNodeId; + let toNodeId = `${portalNodeData.id}${PORTAL_ID_DELIMITER}${edgeDataFromPortal.toNode}`; + if (!toNodeId.startsWith(PORTAL_ID_PREFIX)) + toNodeId = PORTAL_ID_PREFIX + toNodeId; + addedData.edges.push({ + ...edgeDataFromPortal, + id: newEdgeId, + fromNode: fromNodeId, + toNode: toNodeId + }); + } + const targetSize = this.getPortalSize(CanvasHelper.getBBox(addedData.nodes)); + portalNodeData.width = targetSize.width; + portalNodeData.height = targetSize.height; + return addedData; + } + // Helper functions + getPortalSize(sourceBBox) { + const sourceSize = { + width: sourceBBox.maxX - sourceBBox.minX, + height: sourceBBox.maxY - sourceBBox.minY + }; + const targetSize = { + width: Math.max(sourceSize.width + PORTAL_PADDING * 2, MIN_OPEN_PORTAL_SIZE.width), + height: Math.max(sourceSize.height + PORTAL_PADDING * 2, MIN_OPEN_PORTAL_SIZE.height) + }; + if (!Number.isFinite(targetSize.width)) targetSize.width = MIN_OPEN_PORTAL_SIZE.width; + if (!Number.isFinite(targetSize.height)) targetSize.height = MIN_OPEN_PORTAL_SIZE.height; + return targetSize; + } + getContainingNodes(canvas, portalNode, directChildren = true) { + return Array.from(canvas.nodes.values()).filter((node) => this.isChildOfPortal(portalNode.getData(), node.getData(), directChildren)); + } + getContainingEdges(canvas, portalNode, directChildren = true) { + return Array.from(canvas.edges.values()).filter((edge) => this.isChildOfPortal(portalNode.getData(), edge.getData(), directChildren)); + } + getParentPortalId(elementId) { + const nestedIds = _PortalsCanvasExtension.getNestedIds(elementId); + if (nestedIds.length < 2) return void 0; + return nestedIds.slice(0, -1).join(PORTAL_ID_DELIMITER); + } + static getNestedIds(id) { + if (!this.isPortalElement(id)) return [id]; + const trimmedId = id.substring(PORTAL_ID_PREFIX.length); + return trimmedId.split(PORTAL_ID_DELIMITER); + } + static isPortalElement(id) { + return id.startsWith(PORTAL_ID_PREFIX); + } + isChildOfPortal(portal, canvasElement, directChild = true) { + const nestedIds = _PortalsCanvasExtension.getNestedIds(canvasElement.id); + if (nestedIds.length < 2) return false; + return canvasElement.id !== portal.id && // Not the portal itself + nestedIds.contains(portal.id) && // Is a child of the portal + (!directChild || nestedIds[nestedIds.length - 2] === portal.id); + } +}; + +// src/canvas-extensions/frontmatter-control-button-canvas-extension.ts +var import_obsidian16 = require("obsidian"); +var FrontmatterControlButtonCanvasExtension = class extends CanvasExtension { + isEnabled() { + return "canvasMetadataCompatibilityEnabled"; + } + init() { + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:canvas-changed", + (canvas) => this.addQuickSettings(canvas) + )); + } + addQuickSettings(canvas) { + var _a; + if (!canvas) return; + const settingsContainer = (_a = canvas.quickSettingsButton) == null ? void 0 : _a.parentElement; + if (!settingsContainer) return; + CanvasHelper.addControlMenuButton( + settingsContainer, + CanvasHelper.createControlMenuButton({ + id: "properties-button", + icon: "info", + label: "Properties", + callback: () => { + var _a2; + const propertiesPlugin = this.plugin.app.internalPlugins.plugins["properties"]; + if (!(propertiesPlugin == null ? void 0 : propertiesPlugin._loaded)) { + new import_obsidian16.Notice(`Core plugin "Properties view" was not found or isn't enabled. Enable it and restart Obsidian.`); + return; + } + let propertiesLeaf = (_a2 = this.plugin.app.workspace.getLeavesOfType("file-properties").first()) != null ? _a2 : null; + if (!propertiesLeaf) { + propertiesLeaf = this.plugin.app.workspace.getRightLeaf(false); + propertiesLeaf == null ? void 0 : propertiesLeaf.setViewState({ type: "file-properties" }); + } + if (propertiesLeaf) this.plugin.app.workspace.revealLeaf(propertiesLeaf); + } + }) + ); + } +}; + +// src/canvas-extensions/better-default-settings-canvas-extension.ts +var BetterDefaultSettingsCanvasExtension = class extends CanvasExtension { + isEnabled() { + return true; + } + init() { + this.modifyCanvasSettings(this.plugin.getCurrentCanvas()); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:settings-changed", + () => this.modifyCanvasSettings(this.plugin.getCurrentCanvas()) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:canvas-changed", + (canvas) => this.modifyCanvasSettings(canvas) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:double-click", + (canvas, event, preventDefault) => this.onDoubleClick(canvas, event, preventDefault) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-created", + (canvas, node) => { + this.enforceNodeGridAlignment(canvas, node); + this.applyDefaultNodeStyles(canvas, node); + } + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:edge-created", + (canvas, edge) => this.applyDefaultEdgeStyles(canvas, edge) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-resized", + (canvas, node) => this.enforceMaxNodeWidth(canvas, node) + )); + } + modifyCanvasSettings(canvas) { + if (!canvas) return; + const defaultTextNodeDimensionsArray = this.plugin.settings.getSetting("defaultTextNodeDimensions"); + canvas.config.defaultTextNodeDimensions = { + width: defaultTextNodeDimensionsArray[0], + height: defaultTextNodeDimensionsArray[1] + }; + const defaultFileNodeDimensionsArray = this.plugin.settings.getSetting("defaultFileNodeDimensions"); + canvas.config.defaultFileNodeDimensions = { + width: defaultFileNodeDimensionsArray[0], + height: defaultFileNodeDimensionsArray[1] + }; + canvas.config.minContainerDimension = this.plugin.settings.getSetting("minNodeSize"); + } + async onDoubleClick(canvas, event, preventDefault) { + if (event.defaultPrevented || event.target !== canvas.wrapperEl || canvas.isDragging || canvas.readonly) return; + preventDefault.value = true; + const pos = canvas.posFromEvt(event); + switch (this.plugin.settings.getSetting("nodeTypeOnDoubleClick")) { + case "file": { + const file = await new FileSelectModal(this.plugin.app, void 0, true).awaitInput(); + canvas.createFileNode({ + pos, + position: "center", + file + }); + break; + } + default: + canvas.createTextNode({ + pos, + position: "center" + }); + break; + } + } + enforceNodeGridAlignment(_canvas, node) { + if (!this.plugin.settings.getSetting("alignNewNodesToGrid")) return; + const nodeData = node.getData(); + node.setData({ + ...nodeData, + x: CanvasHelper.alignToGrid(nodeData.x), + y: CanvasHelper.alignToGrid(nodeData.y) + }); + } + applyDefaultNodeStyles(_canvas, node) { + const nodeData = node.getData(); + if (nodeData.type !== "text") return; + let color = this.plugin.settings.getSetting("defaultTextNodeColor").toString(); + if (color === "0") color = void 0; + node.setData({ + ...nodeData, + color, + styleAttributes: { + ...nodeData.styleAttributes, + ...this.plugin.settings.getSetting("defaultTextNodeStyleAttributes") + } + }); + } + async applyDefaultEdgeStyles(canvas, edge) { + var _a; + const edgeData = edge.getData(); + let color = this.plugin.settings.getSetting("defaultEdgeColor").toString(); + if (this.plugin.settings.getSetting("inheritEdgeColorFromNode")) + color = (_a = edge.from.node.getData().color) != null ? _a : color; + if (color === "0") color = void 0; + edge.setData({ + ...edgeData, + color, + styleAttributes: { + ...edgeData.styleAttributes, + ...this.plugin.settings.getSetting("defaultEdgeStyleAttributes") + } + }); + if (canvas.canvasEl.hasClass("is-connecting")) { + await new Promise((resolve) => { + new MutationObserver(() => { + if (!canvas.canvasEl.hasClass("is-connecting")) resolve(); + }).observe(canvas.canvasEl, { attributes: true, attributeFilter: ["class"] }); + }); + } + const lineDirection = this.plugin.settings.getSetting("defaultEdgeLineDirection"); + edge.setData({ + ...edge.getData(), + fromEnd: lineDirection === "bidirectional" ? "arrow" : "none", + toEnd: lineDirection === "nondirectional" ? "none" : "arrow" + }); + } + enforceMaxNodeWidth(_canvas, node) { + const maxNodeWidth = this.plugin.settings.getSetting("maxNodeWidth"); + if (maxNodeWidth <= 0) return; + const nodeData = node.getData(); + if (nodeData.type !== "text" && nodeData.type !== "file" || nodeData.portal) return; + if (nodeData.width <= maxNodeWidth) return; + node.setData({ + ...nodeData, + x: node.prevX !== void 0 ? node.prevX : nodeData.x, + // Reset the position to the previous value + width: maxNodeWidth + }); + } +}; + +// src/canvas-extensions/color-palette-canvas-extension.ts +var DEFAULT_COLORS_COUNT = 6; +var CUSTOM_COLORS_MOD_STYLES_ID = "mod-custom-colors"; +var ColorPaletteCanvasExtension = class extends CanvasExtension { + constructor() { + super(...arguments); + this.observer = null; + } + isEnabled() { + return true; + } + init() { + this.plugin.registerEvent(this.plugin.app.workspace.on( + "window-open", + (_win, _window) => this.updateCustomColorModStyleClasses() + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "css-change", + () => this.updateCustomColorModStyleClasses() + )); + this.updateCustomColorModStyleClasses(); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:popup-menu-created", + (canvas) => this.patchColorSelection(canvas) + )); + this.plugin.register(() => { + var _a; + return (_a = this.observer) == null ? void 0 : _a.disconnect(); + }); + } + updateCustomColorModStyleClasses() { + var _a; + const customCss = this.getCustomColors().map((colorId) => ` + .mod-canvas-color-${colorId} { + --canvas-color: var(--canvas-color-${colorId}); + } + `).join(""); + for (const win of this.plugin.windowsManager.windows) { + const doc = win.document; + (_a = doc.getElementById(CUSTOM_COLORS_MOD_STYLES_ID)) == null ? void 0 : _a.remove(); + const customColorModStyle = doc.createElement("style"); + customColorModStyle.id = CUSTOM_COLORS_MOD_STYLES_ID; + doc.head.appendChild(customColorModStyle); + customColorModStyle.textContent = customCss; + } + } + patchColorSelection(canvas) { + if (this.observer) this.observer.disconnect(); + this.observer = new MutationObserver((mutations) => { + const colorMenuOpened = mutations.some( + (mutation) => Object.values(mutation.addedNodes).some( + (node) => node instanceof HTMLElement && node.classList.contains("canvas-submenu") && Object.values(node.childNodes).some( + (node2) => node2 instanceof HTMLElement && node2.classList.contains("canvas-color-picker-item") + ) + ) + ); + if (!colorMenuOpened) return; + const submenu = canvas.menu.menuEl.querySelector(".canvas-submenu"); + if (!submenu) return; + const currentNodeColor = canvas.getSelectionData().nodes.map((node) => node.color).last(); + for (const colorId of this.getCustomColors()) { + const customColorMenuItem = this.createColorMenuItem(canvas, colorId); + if (currentNodeColor === colorId) customColorMenuItem.classList.add("is-active"); + submenu.insertBefore(customColorMenuItem, submenu.lastChild); + } + }); + this.observer.observe(canvas.menu.menuEl, { childList: true }); + } + createColorMenuItem(canvas, colorId) { + const menuItem = document.createElement("div"); + menuItem.classList.add("canvas-color-picker-item"); + menuItem.classList.add(`mod-canvas-color-${colorId}`); + menuItem.addEventListener("click", () => { + menuItem.classList.add("is-active"); + for (const item of canvas.selection) { + item.setColor(colorId); + } + canvas.requestSave(); + }); + return menuItem; + } + getCustomColors() { + const colors = []; + const style = getComputedStyle(document.body); + let colorIndex = DEFAULT_COLORS_COUNT + 1; + while (style.getPropertyValue(`--canvas-color-${colorIndex}`)) { + colors.push(colorIndex.toString()); + colorIndex++; + } + return colors; + } +}; + +// src/canvas-extensions/collapsible-groups-canvas-extension.ts +var import_obsidian17 = require("obsidian"); +var CollapsibleGroupsCanvasExtension = class extends CanvasExtension { + isEnabled() { + return "collapsibleGroupsFeatureEnabled"; + } + init() { + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-changed", + (canvas, node) => this.onNodeChanged(canvas, node) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-bbox-requested", + (canvas, node, bbox) => this.onNodeBBoxRequested(canvas, node, bbox) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:copy", + (canvas, selectionData) => this.onCopy(canvas, selectionData) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:data-requested", + (_canvas, data) => this.expandNodes(data) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:data-loaded:before", + (_canvas, data, _setData) => this.collapseNodes(data) + )); + this.plugin.addCommand({ + id: "toggle-collapse-group", + name: "Toggle collapse group", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (canvas) => canvas.selection.size === 1 && canvas.selection.values().next().value.getData().type === "group", + (canvas) => this.toggleCollapseGroup(canvas, canvas.selection.values().next().value) + ) + }); + } + toggleCollapseGroup(canvas, node) { + const data = node.getData(); + this.setCollapsed(node.canvas, node, data.collapsed ? void 0 : true); + canvas.markMoved(node); + } + onNodeChanged(canvas, groupNode) { + var _a, _b; + const groupNodeData = groupNode.getData(); + if (groupNodeData.type !== "group") return; + (_a = groupNode.collapseEl) == null ? void 0 : _a.remove(); + const collapseEl = document.createElement("span"); + collapseEl.className = "collapse-button"; + (0, import_obsidian17.setIcon)(collapseEl, groupNodeData.collapsed ? "plus-circle" : "minus-circle"); + collapseEl.onclick = () => this.toggleCollapseGroup(canvas, groupNode); + groupNode.collapseEl = collapseEl; + (_b = groupNode.labelEl) == null ? void 0 : _b.insertAdjacentElement("afterend", collapseEl); + } + onCopy(_canvas, selectionData) { + for (const collapsedGroupData of selectionData.nodes) { + if (collapsedGroupData.type !== "group" || !collapsedGroupData.collapsed || !collapsedGroupData.collapsedData) continue; + selectionData.nodes.push(...collapsedGroupData.collapsedData.nodes.map((nodeData) => ({ + ...nodeData, + // Restore the relative position of the node to the group + x: nodeData.x + collapsedGroupData.x, + y: nodeData.y + collapsedGroupData.y + }))); + selectionData.edges.push(...collapsedGroupData.collapsedData.edges); + } + } + setCollapsed(canvas, groupNode, collapsed) { + groupNode.setData({ ...groupNode.getData(), collapsed }); + canvas.setData(canvas.getData()); + canvas.history.current--; + canvas.pushHistory(canvas.getData()); + canvas.requestSave(); + } + onNodeBBoxRequested(canvas, node, bbox) { + var _a, _b; + const nodeData = node.getData(); + if (nodeData.type !== "group" || !nodeData.collapsed) return; + const collapseElBBox = (_a = node.collapseEl) == null ? void 0 : _a.getBoundingClientRect(); + if (!collapseElBBox) return; + const labelElBBox = (_b = node.labelEl) == null ? void 0 : _b.getBoundingClientRect(); + if (!labelElBBox) return; + const minPos = canvas.posFromClient({ x: collapseElBBox.left, y: collapseElBBox.top }); + const maxPos = canvas.posFromClient({ x: labelElBBox.right, y: collapseElBBox.bottom }); + bbox.minX = minPos.x; + bbox.minY = minPos.y; + bbox.maxX = maxPos.x; + bbox.maxY = maxPos.y; + } + expandNodes(data) { + var _a; + if (!data) return; + data.nodes = (_a = data.nodes) == null ? void 0 : _a.flatMap((groupNodeData) => { + const collapsedData = groupNodeData.collapsedData; + if (collapsedData === void 0) return [groupNodeData]; + delete groupNodeData.collapsedData; + data.edges.push(...collapsedData.edges); + return [groupNodeData, ...collapsedData.nodes.map((nodeData) => ({ + ...nodeData, + // Restore the relative position of the node to the group + x: nodeData.x + groupNodeData.x, + y: nodeData.y + groupNodeData.y + }))]; + }); + } + collapseNodes(data) { + var _a; + (_a = data == null ? void 0 : data.nodes) == null ? void 0 : _a.forEach((groupNodeData) => { + var _a2, _b, _c, _d; + if (!groupNodeData.collapsed) return; + const groupNodeBBox = CanvasHelper.getBBox([groupNodeData]); + const containedNodesData = data.nodes.filter( + (nodeData) => nodeData.id !== groupNodeData.id && BBoxHelper.insideBBox(CanvasHelper.getBBox([nodeData]), groupNodeBBox, false) + ); + const containedEdgesData = data.edges.filter((edgeData) => { + return containedNodesData.some((nodeData) => nodeData.id === edgeData.fromNode) || containedNodesData.some((nodeData) => nodeData.id === edgeData.toNode); + }); + data.nodes = data.nodes.filter((nodeData) => !containedNodesData.includes(nodeData)); + data.edges = data.edges.filter((edgeData) => !containedEdgesData.includes(edgeData)); + const newContainedNodesData = containedNodesData.filter((nodeData) => { + var _a3, _b2, _c2; + return !((_c2 = (_b2 = (_a3 = groupNodeData.collapsedData) == null ? void 0 : _a3.nodes) == null ? void 0 : _b2.some((e) => e.id === nodeData.id)) != null ? _c2 : false); + }); + const newContainedEdgesData = containedEdgesData.filter((edgeData) => { + var _a3, _b2, _c2; + return !((_c2 = (_b2 = (_a3 = groupNodeData.collapsedData) == null ? void 0 : _a3.edges) == null ? void 0 : _b2.some((n) => n.id === edgeData.id)) != null ? _c2 : false); + }); + groupNodeData.collapsedData = { + nodes: [ + ...(_b = (_a2 = groupNodeData.collapsedData) == null ? void 0 : _a2.nodes) != null ? _b : [], + ...newContainedNodesData.map((nodeData) => ({ + ...nodeData, + // Store the relative position of the node to the group + x: nodeData.x - groupNodeData.x, + y: nodeData.y - groupNodeData.y + })) + ], + edges: [ + ...(_d = (_c = groupNodeData.collapsedData) == null ? void 0 : _c.edges) != null ? _d : [], + ...newContainedEdgesData + ] + }; + }); + } +}; + +// src/canvas-extensions/focus-mode-canvas-extension.ts +var CONTROL_MENU_FOCUS_TOGGLE_ID = "focus-mode-toggle"; +var FocusModeCanvasExtension = class extends CanvasExtension { + isEnabled() { + return "focusModeFeatureEnabled"; + } + init() { + this.plugin.addCommand({ + id: "toggle-focus-mode", + name: "Toggle Focus Mode", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (_canvas) => true, + (canvas) => this.toggleFocusMode(canvas) + ) + }); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:canvas-changed", + (canvas) => this.addControlMenuToggle(canvas) + )); + } + addControlMenuToggle(canvas) { + var _a; + const settingsContainer = (_a = canvas.quickSettingsButton) == null ? void 0 : _a.parentElement; + if (!settingsContainer) return; + const controlMenuFocusToggle = CanvasHelper.createControlMenuButton({ + id: CONTROL_MENU_FOCUS_TOGGLE_ID, + label: "Focus Mode", + icon: "focus", + callback: () => this.toggleFocusMode(canvas) + }); + CanvasHelper.addControlMenuButton(settingsContainer, controlMenuFocusToggle); + } + toggleFocusMode(canvas) { + var _a, _b; + const controlMenuFocusToggle = (_b = (_a = canvas.quickSettingsButton) == null ? void 0 : _a.parentElement) == null ? void 0 : _b.querySelector(`#${CONTROL_MENU_FOCUS_TOGGLE_ID}`); + if (!controlMenuFocusToggle) return; + const newValue = controlMenuFocusToggle.dataset.toggled !== "true"; + canvas.wrapperEl.dataset.focusModeEnabled = newValue.toString(); + controlMenuFocusToggle.dataset.toggled = newValue.toString(); + } +}; + +// src/canvas-extensions/auto-file-node-edges-canvas-extension.ts +var AUTO_EDGE_ID_PREFIX = "afe"; +var AutoFileNodeEdgesCanvasExtension = class extends CanvasExtension { + isEnabled() { + return "autoFileNodeEdgesFeatureEnabled"; + } + init() { + this.plugin.registerEvent(this.plugin.app.metadataCache.on("changed", (file) => { + for (const canvas of this.plugin.getCanvases()) + this.onMetadataChanged(canvas, file); + })); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-added", + (canvas, node) => this.onNodeChanged(canvas, node) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-changed", + (canvas, node) => this.onNodeChanged(canvas, node) + )); + } + onMetadataChanged(canvas, file) { + var _a; + for (const node of canvas.nodes.values()) { + if (node.getData().type !== "file" || ((_a = node.file) == null ? void 0 : _a.path) !== file.path) continue; + this.updateFileNodeEdges(canvas, node); + } + } + onNodeChanged(canvas, node) { + if (node.getData().type !== "file") return; + for (const node2 of canvas.nodes.values()) { + if (node2.getData().type !== "file") continue; + this.updateFileNodeEdges(canvas, node2); + } + } + updateFileNodeEdges(canvas, node) { + const edges = this.getFileNodeEdges(canvas, node); + const newEdges = Array.from(edges.values()).filter((edge) => !canvas.edges.has(edge.id)); + canvas.importData({ nodes: [], edges: newEdges }, false, false); + for (const edge of canvas.edges.values()) { + if (edge.id.startsWith(`${AUTO_EDGE_ID_PREFIX}${node.id}`) && !edges.has(edge.id)) + canvas.removeEdge(edge); + } + } + getFileNodeEdges(canvas, node) { + var _a, _b; + const canvasFile = canvas.view.file; + if (!canvasFile || !node.file) return /* @__PURE__ */ new Map(); + const fileMetadata = this.plugin.app.metadataCache.getFileCache(node.file); + if (!fileMetadata) return /* @__PURE__ */ new Map(); + const linkedFilesFrontmatterKey = this.plugin.settings.getSetting("autoFileNodeEdgesFrontmatterKey"); + const fileLinksToBeLinkedTo = (_b = (_a = fileMetadata.frontmatterLinks) == null ? void 0 : _a.filter((link) => link.key.split(".")[0] === linkedFilesFrontmatterKey)) != null ? _b : []; + const filepathsToBeLinkedTo = fileLinksToBeLinkedTo.map((link) => this.plugin.app.metadataCache.getFirstLinkpathDest(link.link, canvasFile.path)).map((file) => file == null ? void 0 : file.path).filter((path) => path !== null); + const nodesToBeLinkedTo = Array.from(canvas.nodes.values()).filter((otherNode) => { + var _a2; + return otherNode.id !== node.id && filepathsToBeLinkedTo.includes((_a2 = otherNode.file) == null ? void 0 : _a2.path); + }); + const newEdges = /* @__PURE__ */ new Map(); + for (const otherNode of nodesToBeLinkedTo) { + const edgeId = `${AUTO_EDGE_ID_PREFIX}${node.id}${otherNode.id}`; + const bestFromSide = CanvasHelper.getBestSideForFloatingEdge(BBoxHelper.getCenterOfBBoxSide(otherNode.getBBox(), "right"), node); + const bestToSide = CanvasHelper.getBestSideForFloatingEdge(BBoxHelper.getCenterOfBBoxSide(node.getBBox(), "left"), otherNode); + newEdges.set(edgeId, { + id: edgeId, + fromNode: node.id, + fromSide: bestFromSide, + fromFloating: true, + toNode: otherNode.id, + toSide: bestToSide, + toFloating: true + }); + } + return newEdges; + } +}; + +// src/canvas-extensions/flip-edge-canvas-extension.ts +var FlipEdgeCanvasExtension = class extends CanvasExtension { + isEnabled() { + return "flipEdgeFeatureEnabled"; + } + init() { + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:popup-menu-created", + (canvas) => this.onPopupMenuCreated(canvas) + )); + } + onPopupMenuCreated(canvas) { + var _a, _b; + const popupMenuEl = (_a = canvas == null ? void 0 : canvas.menu) == null ? void 0 : _a.menuEl; + if (!popupMenuEl) return; + const POSSIBLE_ICONS = ["lucide-arrow-right", "lucide-move-horizontal", "line-horizontal"]; + let edgeDirectionButton = null; + for (const icon of POSSIBLE_ICONS) { + edgeDirectionButton = (_b = popupMenuEl.querySelector(`button:not([id]) > .svg-icon.${icon}`)) == null ? void 0 : _b.parentElement; + if (edgeDirectionButton) break; + } + if (!edgeDirectionButton) return; + edgeDirectionButton.addEventListener("click", () => this.onEdgeDirectionDropdownCreated(canvas)); + } + onEdgeDirectionDropdownCreated(canvas) { + const dropdownEl = document.body.querySelector("div.menu"); + if (!dropdownEl) return; + const separatorEl = CanvasHelper.createDropdownSeparatorElement(); + dropdownEl.appendChild(separatorEl); + const flipEdgeButton = CanvasHelper.createDropdownOptionElement({ + icon: "flip-horizontal-2", + label: "Flip Edge", + callback: () => this.flipEdge(canvas) + }); + dropdownEl.appendChild(flipEdgeButton); + } + flipEdge(canvas) { + const selectedEdges = [...canvas.selection].filter((item) => item.path !== void 0); + if (selectedEdges.length === 0) return; + for (const edge of selectedEdges) { + edge.update({ + ...edge.from, + node: edge.to.node, + side: edge.to.side + }, { + ...edge.to, + node: edge.from.node, + side: edge.from.side + }); + } + canvas.pushHistory(canvas.getData()); + } +}; + +// src/canvas-extensions/edge-selection-canvas-extension.ts +var DIRECTION_MENU_MAP = { + connected: { + id: "select-connected-edges", + icon: "arrows-selected", + label: "Select Connected Edges" + }, + outgoing: { + id: "select-outgoing-edges", + icon: "arrow-right-selected", + label: "Select Outgoing Edges" + }, + incoming: { + id: "select-incoming-edges", + icon: "arrow-left-selected", + label: "Select Incoming Edges" + } +}; +var EdgeSelectionCanvasExtension = class extends CanvasExtension { + isEnabled() { + return "edgeSelectionEnabled"; + } + init() { + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:popup-menu-created", + (canvas) => this.onPopupMenuCreated(canvas) + )); + } + onPopupMenuCreated(canvas) { + var _a; + const popupMenuEl = (_a = canvas == null ? void 0 : canvas.menu) == null ? void 0 : _a.menuEl; + if (!popupMenuEl) return; + const selectionNodeData = canvas.getSelectionData().nodes; + if (canvas.readonly || selectionNodeData.length === 0) return; + const selectEdgeByDirection = this.plugin.settings.getSetting("selectEdgeByDirection"); + const menuDirectionSet = /* @__PURE__ */ new Set(["connected"]); + if (selectionNodeData.length === 1) { + const node = canvas.nodes.get(selectionNodeData[0].id); + if (!node) return; + const edges = canvas.getEdgesForNode(node); + if (edges.length === 0) return; + if (selectEdgeByDirection) { + edges.forEach((edge) => { + if (edge.from.node === node) { + menuDirectionSet.add("outgoing"); + } else if (edge.to.node === node) { + menuDirectionSet.add("incoming"); + } + }); + } + } else if (selectEdgeByDirection) { + menuDirectionSet.add("outgoing"); + menuDirectionSet.add("incoming"); + } + menuDirectionSet.forEach((direction) => { + const config = DIRECTION_MENU_MAP[direction]; + CanvasHelper.addPopupMenuOption(canvas, CanvasHelper.createPopupMenuOption({ + ...config, + callback: () => CanvasHelper.selectEdgesForNodes(canvas, direction) + })); + }); + } +}; + +// node_modules/html-to-image/es/util.js +function resolveUrl(url, baseUrl) { + if (url.match(/^[a-z]+:\/\//i)) { + return url; + } + if (url.match(/^\/\//)) { + return window.location.protocol + url; + } + if (url.match(/^[a-z]+:/i)) { + return url; + } + const doc = document.implementation.createHTMLDocument(); + const base = doc.createElement("base"); + const a = doc.createElement("a"); + doc.head.appendChild(base); + doc.body.appendChild(a); + if (baseUrl) { + base.href = baseUrl; + } + a.href = url; + return a.href; +} +var uuid = /* @__PURE__ */ (() => { + let counter = 0; + const random = () => ( + // eslint-disable-next-line no-bitwise + `0000${(Math.random() * 36 ** 4 << 0).toString(36)}`.slice(-4) + ); + return () => { + counter += 1; + return `u${random()}${counter}`; + }; +})(); +function toArray(arrayLike) { + const arr = []; + for (let i = 0, l = arrayLike.length; i < l; i++) { + arr.push(arrayLike[i]); + } + return arr; +} +function px(node, styleProperty) { + const win = node.ownerDocument.defaultView || window; + const val = win.getComputedStyle(node).getPropertyValue(styleProperty); + return val ? parseFloat(val.replace("px", "")) : 0; +} +function getNodeWidth(node) { + const leftBorder = px(node, "border-left-width"); + const rightBorder = px(node, "border-right-width"); + return node.clientWidth + leftBorder + rightBorder; +} +function getNodeHeight(node) { + const topBorder = px(node, "border-top-width"); + const bottomBorder = px(node, "border-bottom-width"); + return node.clientHeight + topBorder + bottomBorder; +} +function getImageSize(targetNode, options = {}) { + const width = options.width || getNodeWidth(targetNode); + const height = options.height || getNodeHeight(targetNode); + return { width, height }; +} +function getPixelRatio() { + let ratio; + let FINAL_PROCESS; + try { + FINAL_PROCESS = process; + } catch (e) { + } + const val = FINAL_PROCESS && FINAL_PROCESS.env ? FINAL_PROCESS.env.devicePixelRatio : null; + if (val) { + ratio = parseInt(val, 10); + if (Number.isNaN(ratio)) { + ratio = 1; + } + } + return ratio || window.devicePixelRatio || 1; +} +var canvasDimensionLimit = 16384; +function checkCanvasDimensions(canvas) { + if (canvas.width > canvasDimensionLimit || canvas.height > canvasDimensionLimit) { + if (canvas.width > canvasDimensionLimit && canvas.height > canvasDimensionLimit) { + if (canvas.width > canvas.height) { + canvas.height *= canvasDimensionLimit / canvas.width; + canvas.width = canvasDimensionLimit; + } else { + canvas.width *= canvasDimensionLimit / canvas.height; + canvas.height = canvasDimensionLimit; + } + } else if (canvas.width > canvasDimensionLimit) { + canvas.height *= canvasDimensionLimit / canvas.width; + canvas.width = canvasDimensionLimit; + } else { + canvas.width *= canvasDimensionLimit / canvas.height; + canvas.height = canvasDimensionLimit; + } + } +} +function createImage(url) { + return new Promise((resolve, reject) => { + const img = new Image(); + img.decode = () => resolve(img); + img.onload = () => resolve(img); + img.onerror = reject; + img.crossOrigin = "anonymous"; + img.decoding = "async"; + img.src = url; + }); +} +async function svgToDataURL(svg) { + return Promise.resolve().then(() => new XMLSerializer().serializeToString(svg)).then(encodeURIComponent).then((html) => `data:image/svg+xml;charset=utf-8,${html}`); +} +async function nodeToDataURL(node, width, height) { + const xmlns = "http://www.w3.org/2000/svg"; + const svg = document.createElementNS(xmlns, "svg"); + const foreignObject = document.createElementNS(xmlns, "foreignObject"); + svg.setAttribute("width", `${width}`); + svg.setAttribute("height", `${height}`); + svg.setAttribute("viewBox", `0 0 ${width} ${height}`); + foreignObject.setAttribute("width", "100%"); + foreignObject.setAttribute("height", "100%"); + foreignObject.setAttribute("x", "0"); + foreignObject.setAttribute("y", "0"); + foreignObject.setAttribute("externalResourcesRequired", "true"); + svg.appendChild(foreignObject); + foreignObject.appendChild(node); + return svgToDataURL(svg); +} +var isInstanceOfElement = (node, instance) => { + if (node instanceof instance) + return true; + const nodePrototype = Object.getPrototypeOf(node); + if (nodePrototype === null) + return false; + return nodePrototype.constructor.name === instance.name || isInstanceOfElement(nodePrototype, instance); +}; + +// node_modules/html-to-image/es/clone-pseudos.js +function formatCSSText(style) { + const content = style.getPropertyValue("content"); + return `${style.cssText} content: '${content.replace(/'|"/g, "")}';`; +} +function formatCSSProperties(style) { + return toArray(style).map((name) => { + const value = style.getPropertyValue(name); + const priority = style.getPropertyPriority(name); + return `${name}: ${value}${priority ? " !important" : ""};`; + }).join(" "); +} +function getPseudoElementStyle(className, pseudo, style) { + const selector = `.${className}:${pseudo}`; + const cssText = style.cssText ? formatCSSText(style) : formatCSSProperties(style); + return document.createTextNode(`${selector}{${cssText}}`); +} +function clonePseudoElement(nativeNode, clonedNode, pseudo) { + const style = window.getComputedStyle(nativeNode, pseudo); + const content = style.getPropertyValue("content"); + if (content === "" || content === "none") { + return; + } + const className = uuid(); + try { + clonedNode.className = `${clonedNode.className} ${className}`; + } catch (err) { + return; + } + const styleElement = document.createElement("style"); + styleElement.appendChild(getPseudoElementStyle(className, pseudo, style)); + clonedNode.appendChild(styleElement); +} +function clonePseudoElements(nativeNode, clonedNode) { + clonePseudoElement(nativeNode, clonedNode, ":before"); + clonePseudoElement(nativeNode, clonedNode, ":after"); +} + +// node_modules/html-to-image/es/mimes.js +var WOFF = "application/font-woff"; +var JPEG = "image/jpeg"; +var mimes = { + woff: WOFF, + woff2: WOFF, + ttf: "application/font-truetype", + eot: "application/vnd.ms-fontobject", + png: "image/png", + jpg: JPEG, + jpeg: JPEG, + gif: "image/gif", + tiff: "image/tiff", + svg: "image/svg+xml", + webp: "image/webp" +}; +function getExtension(url) { + const match = /\.([^./]*?)$/g.exec(url); + return match ? match[1] : ""; +} +function getMimeType(url) { + const extension = getExtension(url).toLowerCase(); + return mimes[extension] || ""; +} + +// node_modules/html-to-image/es/dataurl.js +function getContentFromDataUrl(dataURL) { + return dataURL.split(/,/)[1]; +} +function isDataUrl(url) { + return url.search(/^(data:)/) !== -1; +} +function makeDataUrl(content, mimeType) { + return `data:${mimeType};base64,${content}`; +} +async function fetchAsDataURL(url, init, process2) { + const res = await fetch(url, init); + if (res.status === 404) { + throw new Error(`Resource "${res.url}" not found`); + } + const blob = await res.blob(); + return new Promise((resolve, reject) => { + const reader = new FileReader(); + reader.onerror = reject; + reader.onloadend = () => { + try { + resolve(process2({ res, result: reader.result })); + } catch (error) { + reject(error); + } + }; + reader.readAsDataURL(blob); + }); +} +var cache = {}; +function getCacheKey(url, contentType, includeQueryParams) { + let key = url.replace(/\?.*/, ""); + if (includeQueryParams) { + key = url; + } + if (/ttf|otf|eot|woff2?/i.test(key)) { + key = key.replace(/.*\//, ""); + } + return contentType ? `[${contentType}]${key}` : key; +} +async function resourceToDataURL(resourceUrl, contentType, options) { + const cacheKey = getCacheKey(resourceUrl, contentType, options.includeQueryParams); + if (cache[cacheKey] != null) { + return cache[cacheKey]; + } + if (options.cacheBust) { + resourceUrl += (/\?/.test(resourceUrl) ? "&" : "?") + (/* @__PURE__ */ new Date()).getTime(); + } + let dataURL; + try { + const content = await fetchAsDataURL(resourceUrl, options.fetchRequestInit, ({ res, result }) => { + if (!contentType) { + contentType = res.headers.get("Content-Type") || ""; + } + return getContentFromDataUrl(result); + }); + dataURL = makeDataUrl(content, contentType); + } catch (error) { + dataURL = options.imagePlaceholder || ""; + let msg = `Failed to fetch resource: ${resourceUrl}`; + if (error) { + msg = typeof error === "string" ? error : error.message; + } + if (msg) { + console.warn(msg); + } + } + cache[cacheKey] = dataURL; + return dataURL; +} + +// node_modules/html-to-image/es/clone-node.js +async function cloneCanvasElement(canvas) { + const dataURL = canvas.toDataURL(); + if (dataURL === "data:,") { + return canvas.cloneNode(false); + } + return createImage(dataURL); +} +async function cloneVideoElement(video, options) { + if (video.currentSrc) { + const canvas = document.createElement("canvas"); + const ctx = canvas.getContext("2d"); + canvas.width = video.clientWidth; + canvas.height = video.clientHeight; + ctx === null || ctx === void 0 ? void 0 : ctx.drawImage(video, 0, 0, canvas.width, canvas.height); + const dataURL2 = canvas.toDataURL(); + return createImage(dataURL2); + } + const poster = video.poster; + const contentType = getMimeType(poster); + const dataURL = await resourceToDataURL(poster, contentType, options); + return createImage(dataURL); +} +async function cloneIFrameElement(iframe) { + var _a; + try { + if ((_a = iframe === null || iframe === void 0 ? void 0 : iframe.contentDocument) === null || _a === void 0 ? void 0 : _a.body) { + return await cloneNode(iframe.contentDocument.body, {}, true); + } + } catch (_b) { + } + return iframe.cloneNode(false); +} +async function cloneSingleNode(node, options) { + if (isInstanceOfElement(node, HTMLCanvasElement)) { + return cloneCanvasElement(node); + } + if (isInstanceOfElement(node, HTMLVideoElement)) { + return cloneVideoElement(node, options); + } + if (isInstanceOfElement(node, HTMLIFrameElement)) { + return cloneIFrameElement(node); + } + return node.cloneNode(false); +} +var isSlotElement = (node) => node.tagName != null && node.tagName.toUpperCase() === "SLOT"; +async function cloneChildren(nativeNode, clonedNode, options) { + var _a, _b; + let children = []; + if (isSlotElement(nativeNode) && nativeNode.assignedNodes) { + children = toArray(nativeNode.assignedNodes()); + } else if (isInstanceOfElement(nativeNode, HTMLIFrameElement) && ((_a = nativeNode.contentDocument) === null || _a === void 0 ? void 0 : _a.body)) { + children = toArray(nativeNode.contentDocument.body.childNodes); + } else { + children = toArray(((_b = nativeNode.shadowRoot) !== null && _b !== void 0 ? _b : nativeNode).childNodes); + } + if (children.length === 0 || isInstanceOfElement(nativeNode, HTMLVideoElement)) { + return clonedNode; + } + await children.reduce((deferred, child) => deferred.then(() => cloneNode(child, options)).then((clonedChild) => { + if (clonedChild) { + clonedNode.appendChild(clonedChild); + } + }), Promise.resolve()); + return clonedNode; +} +function cloneCSSStyle(nativeNode, clonedNode) { + const targetStyle = clonedNode.style; + if (!targetStyle) { + return; + } + const sourceStyle = window.getComputedStyle(nativeNode); + if (sourceStyle.cssText) { + targetStyle.cssText = sourceStyle.cssText; + targetStyle.transformOrigin = sourceStyle.transformOrigin; + } else { + toArray(sourceStyle).forEach((name) => { + let value = sourceStyle.getPropertyValue(name); + if (name === "font-size" && value.endsWith("px")) { + const reducedFont = Math.floor(parseFloat(value.substring(0, value.length - 2))) - 0.1; + value = `${reducedFont}px`; + } + if (isInstanceOfElement(nativeNode, HTMLIFrameElement) && name === "display" && value === "inline") { + value = "block"; + } + if (name === "d" && clonedNode.getAttribute("d")) { + value = `path(${clonedNode.getAttribute("d")})`; + } + targetStyle.setProperty(name, value, sourceStyle.getPropertyPriority(name)); + }); + } +} +function cloneInputValue(nativeNode, clonedNode) { + if (isInstanceOfElement(nativeNode, HTMLTextAreaElement)) { + clonedNode.innerHTML = nativeNode.value; + } + if (isInstanceOfElement(nativeNode, HTMLInputElement)) { + clonedNode.setAttribute("value", nativeNode.value); + } +} +function cloneSelectValue(nativeNode, clonedNode) { + if (isInstanceOfElement(nativeNode, HTMLSelectElement)) { + const clonedSelect = clonedNode; + const selectedOption = Array.from(clonedSelect.children).find((child) => nativeNode.value === child.getAttribute("value")); + if (selectedOption) { + selectedOption.setAttribute("selected", ""); + } + } +} +function decorate(nativeNode, clonedNode) { + if (isInstanceOfElement(clonedNode, Element)) { + cloneCSSStyle(nativeNode, clonedNode); + clonePseudoElements(nativeNode, clonedNode); + cloneInputValue(nativeNode, clonedNode); + cloneSelectValue(nativeNode, clonedNode); + } + return clonedNode; +} +async function ensureSVGSymbols(clone, options) { + const uses = clone.querySelectorAll ? clone.querySelectorAll("use") : []; + if (uses.length === 0) { + return clone; + } + const processedDefs = {}; + for (let i = 0; i < uses.length; i++) { + const use = uses[i]; + const id = use.getAttribute("xlink:href"); + if (id) { + const exist = clone.querySelector(id); + const definition = document.querySelector(id); + if (!exist && definition && !processedDefs[id]) { + processedDefs[id] = await cloneNode(definition, options, true); + } + } + } + const nodes = Object.values(processedDefs); + if (nodes.length) { + const ns = "http://www.w3.org/1999/xhtml"; + const svg = document.createElementNS(ns, "svg"); + svg.setAttribute("xmlns", ns); + svg.style.position = "absolute"; + svg.style.width = "0"; + svg.style.height = "0"; + svg.style.overflow = "hidden"; + svg.style.display = "none"; + const defs = document.createElementNS(ns, "defs"); + svg.appendChild(defs); + for (let i = 0; i < nodes.length; i++) { + defs.appendChild(nodes[i]); + } + clone.appendChild(svg); + } + return clone; +} +async function cloneNode(node, options, isRoot) { + if (!isRoot && options.filter && !options.filter(node)) { + return null; + } + return Promise.resolve(node).then((clonedNode) => cloneSingleNode(clonedNode, options)).then((clonedNode) => cloneChildren(node, clonedNode, options)).then((clonedNode) => decorate(node, clonedNode)).then((clonedNode) => ensureSVGSymbols(clonedNode, options)); +} + +// node_modules/html-to-image/es/embed-resources.js +var URL_REGEX = /url\((['"]?)([^'"]+?)\1\)/g; +var URL_WITH_FORMAT_REGEX = /url\([^)]+\)\s*format\((["']?)([^"']+)\1\)/g; +var FONT_SRC_REGEX = /src:\s*(?:url\([^)]+\)\s*format\([^)]+\)[,;]\s*)+/g; +function toRegex(url) { + const escaped = url.replace(/([.*+?^${}()|\[\]\/\\])/g, "\\$1"); + return new RegExp(`(url\\(['"]?)(${escaped})(['"]?\\))`, "g"); +} +function parseURLs(cssText) { + const urls = []; + cssText.replace(URL_REGEX, (raw, quotation, url) => { + urls.push(url); + return raw; + }); + return urls.filter((url) => !isDataUrl(url)); +} +async function embed(cssText, resourceURL, baseURL, options, getContentFromUrl) { + try { + const resolvedURL = baseURL ? resolveUrl(resourceURL, baseURL) : resourceURL; + const contentType = getMimeType(resourceURL); + let dataURL; + if (getContentFromUrl) { + const content = await getContentFromUrl(resolvedURL); + dataURL = makeDataUrl(content, contentType); + } else { + dataURL = await resourceToDataURL(resolvedURL, contentType, options); + } + return cssText.replace(toRegex(resourceURL), `$1${dataURL}$3`); + } catch (error) { + } + return cssText; +} +function filterPreferredFontFormat(str, { preferredFontFormat }) { + return !preferredFontFormat ? str : str.replace(FONT_SRC_REGEX, (match) => { + while (true) { + const [src, , format] = URL_WITH_FORMAT_REGEX.exec(match) || []; + if (!format) { + return ""; + } + if (format === preferredFontFormat) { + return `src: ${src};`; + } + } + }); +} +function shouldEmbed(url) { + return url.search(URL_REGEX) !== -1; +} +async function embedResources(cssText, baseUrl, options) { + if (!shouldEmbed(cssText)) { + return cssText; + } + const filteredCSSText = filterPreferredFontFormat(cssText, options); + const urls = parseURLs(filteredCSSText); + return urls.reduce((deferred, url) => deferred.then((css) => embed(css, url, baseUrl, options)), Promise.resolve(filteredCSSText)); +} + +// node_modules/html-to-image/es/embed-images.js +async function embedProp(propName, node, options) { + var _a; + const propValue = (_a = node.style) === null || _a === void 0 ? void 0 : _a.getPropertyValue(propName); + if (propValue) { + const cssString = await embedResources(propValue, null, options); + node.style.setProperty(propName, cssString, node.style.getPropertyPriority(propName)); + return true; + } + return false; +} +async function embedBackground(clonedNode, options) { + if (!await embedProp("background", clonedNode, options)) { + await embedProp("background-image", clonedNode, options); + } + if (!await embedProp("mask", clonedNode, options)) { + await embedProp("mask-image", clonedNode, options); + } +} +async function embedImageNode(clonedNode, options) { + const isImageElement = isInstanceOfElement(clonedNode, HTMLImageElement); + if (!(isImageElement && !isDataUrl(clonedNode.src)) && !(isInstanceOfElement(clonedNode, SVGImageElement) && !isDataUrl(clonedNode.href.baseVal))) { + return; + } + const url = isImageElement ? clonedNode.src : clonedNode.href.baseVal; + const dataURL = await resourceToDataURL(url, getMimeType(url), options); + await new Promise((resolve, reject) => { + clonedNode.onload = resolve; + clonedNode.onerror = reject; + const image = clonedNode; + if (image.decode) { + image.decode = resolve; + } + if (image.loading === "lazy") { + image.loading = "eager"; + } + if (isImageElement) { + clonedNode.srcset = ""; + clonedNode.src = dataURL; + } else { + clonedNode.href.baseVal = dataURL; + } + }); +} +async function embedChildren(clonedNode, options) { + const children = toArray(clonedNode.childNodes); + const deferreds = children.map((child) => embedImages(child, options)); + await Promise.all(deferreds).then(() => clonedNode); +} +async function embedImages(clonedNode, options) { + if (isInstanceOfElement(clonedNode, Element)) { + await embedBackground(clonedNode, options); + await embedImageNode(clonedNode, options); + await embedChildren(clonedNode, options); + } +} + +// node_modules/html-to-image/es/apply-style.js +function applyStyle(node, options) { + const { style } = node; + if (options.backgroundColor) { + style.backgroundColor = options.backgroundColor; + } + if (options.width) { + style.width = `${options.width}px`; + } + if (options.height) { + style.height = `${options.height}px`; + } + const manual = options.style; + if (manual != null) { + Object.keys(manual).forEach((key) => { + style[key] = manual[key]; + }); + } + return node; +} + +// node_modules/html-to-image/es/embed-webfonts.js +var cssFetchCache = {}; +async function fetchCSS(url) { + let cache2 = cssFetchCache[url]; + if (cache2 != null) { + return cache2; + } + const res = await fetch(url); + const cssText = await res.text(); + cache2 = { url, cssText }; + cssFetchCache[url] = cache2; + return cache2; +} +async function embedFonts(data, options) { + let cssText = data.cssText; + const regexUrl = /url\(["']?([^"')]+)["']?\)/g; + const fontLocs = cssText.match(/url\([^)]+\)/g) || []; + const loadFonts = fontLocs.map(async (loc) => { + let url = loc.replace(regexUrl, "$1"); + if (!url.startsWith("https://")) { + url = new URL(url, data.url).href; + } + return fetchAsDataURL(url, options.fetchRequestInit, ({ result }) => { + cssText = cssText.replace(loc, `url(${result})`); + return [loc, result]; + }); + }); + return Promise.all(loadFonts).then(() => cssText); +} +function parseCSS(source) { + if (source == null) { + return []; + } + const result = []; + const commentsRegex = /(\/\*[\s\S]*?\*\/)/gi; + let cssText = source.replace(commentsRegex, ""); + const keyframesRegex = new RegExp("((@.*?keyframes [\\s\\S]*?){([\\s\\S]*?}\\s*?)})", "gi"); + while (true) { + const matches = keyframesRegex.exec(cssText); + if (matches === null) { + break; + } + result.push(matches[0]); + } + cssText = cssText.replace(keyframesRegex, ""); + const importRegex = /@import[\s\S]*?url\([^)]*\)[\s\S]*?;/gi; + const combinedCSSRegex = "((\\s*?(?:\\/\\*[\\s\\S]*?\\*\\/)?\\s*?@media[\\s\\S]*?){([\\s\\S]*?)}\\s*?})|(([\\s\\S]*?){([\\s\\S]*?)})"; + const unifiedRegex = new RegExp(combinedCSSRegex, "gi"); + while (true) { + let matches = importRegex.exec(cssText); + if (matches === null) { + matches = unifiedRegex.exec(cssText); + if (matches === null) { + break; + } else { + importRegex.lastIndex = unifiedRegex.lastIndex; + } + } else { + unifiedRegex.lastIndex = importRegex.lastIndex; + } + result.push(matches[0]); + } + return result; +} +async function getCSSRules(styleSheets, options) { + const ret = []; + const deferreds = []; + styleSheets.forEach((sheet) => { + if ("cssRules" in sheet) { + try { + toArray(sheet.cssRules || []).forEach((item, index) => { + if (item.type === CSSRule.IMPORT_RULE) { + let importIndex = index + 1; + const url = item.href; + const deferred = fetchCSS(url).then((metadata) => embedFonts(metadata, options)).then((cssText) => parseCSS(cssText).forEach((rule) => { + try { + sheet.insertRule(rule, rule.startsWith("@import") ? importIndex += 1 : sheet.cssRules.length); + } catch (error) { + console.error("Error inserting rule from remote css", { + rule, + error + }); + } + })).catch((e) => { + console.error("Error loading remote css", e.toString()); + }); + deferreds.push(deferred); + } + }); + } catch (e) { + const inline = styleSheets.find((a) => a.href == null) || document.styleSheets[0]; + if (sheet.href != null) { + deferreds.push(fetchCSS(sheet.href).then((metadata) => embedFonts(metadata, options)).then((cssText) => parseCSS(cssText).forEach((rule) => { + inline.insertRule(rule, sheet.cssRules.length); + })).catch((err) => { + console.error("Error loading remote stylesheet", err); + })); + } + console.error("Error inlining remote css file", e); + } + } + }); + return Promise.all(deferreds).then(() => { + styleSheets.forEach((sheet) => { + if ("cssRules" in sheet) { + try { + toArray(sheet.cssRules || []).forEach((item) => { + ret.push(item); + }); + } catch (e) { + console.error(`Error while reading CSS rules from ${sheet.href}`, e); + } + } + }); + return ret; + }); +} +function getWebFontRules(cssRules) { + return cssRules.filter((rule) => rule.type === CSSRule.FONT_FACE_RULE).filter((rule) => shouldEmbed(rule.style.getPropertyValue("src"))); +} +async function parseWebFontRules(node, options) { + if (node.ownerDocument == null) { + throw new Error("Provided element is not within a Document"); + } + const styleSheets = toArray(node.ownerDocument.styleSheets); + const cssRules = await getCSSRules(styleSheets, options); + return getWebFontRules(cssRules); +} +async function getWebFontCSS(node, options) { + const rules = await parseWebFontRules(node, options); + const cssTexts = await Promise.all(rules.map((rule) => { + const baseUrl = rule.parentStyleSheet ? rule.parentStyleSheet.href : null; + return embedResources(rule.cssText, baseUrl, options); + })); + return cssTexts.join("\n"); +} +async function embedWebFonts(clonedNode, options) { + const cssText = options.fontEmbedCSS != null ? options.fontEmbedCSS : options.skipFonts ? null : await getWebFontCSS(clonedNode, options); + if (cssText) { + const styleNode = document.createElement("style"); + const sytleContent = document.createTextNode(cssText); + styleNode.appendChild(sytleContent); + if (clonedNode.firstChild) { + clonedNode.insertBefore(styleNode, clonedNode.firstChild); + } else { + clonedNode.appendChild(styleNode); + } + } +} + +// node_modules/html-to-image/es/index.js +async function toSvg(node, options = {}) { + const { width, height } = getImageSize(node, options); + const clonedNode = await cloneNode(node, options, true); + await embedWebFonts(clonedNode, options); + await embedImages(clonedNode, options); + applyStyle(clonedNode, options); + const datauri = await nodeToDataURL(clonedNode, width, height); + return datauri; +} +async function toCanvas(node, options = {}) { + const { width, height } = getImageSize(node, options); + const svg = await toSvg(node, options); + const img = await createImage(svg); + const canvas = document.createElement("canvas"); + const context = canvas.getContext("2d"); + const ratio = options.pixelRatio || getPixelRatio(); + const canvasWidth = options.canvasWidth || width; + const canvasHeight = options.canvasHeight || height; + canvas.width = canvasWidth * ratio; + canvas.height = canvasHeight * ratio; + if (!options.skipAutoScale) { + checkCanvasDimensions(canvas); + } + canvas.style.width = `${canvasWidth}`; + canvas.style.height = `${canvasHeight}`; + if (options.backgroundColor) { + context.fillStyle = options.backgroundColor; + context.fillRect(0, 0, canvas.width, canvas.height); + } + context.drawImage(img, 0, 0, canvas.width, canvas.height); + return canvas; +} +async function toPng(node, options = {}) { + const canvas = await toCanvas(node, options); + return canvas.toDataURL(); +} + +// src/canvas-extensions/export-canvas-extension.ts +var import_obsidian18 = require("obsidian"); +var MAX_ALLOWED_LOADING_TIME = 1e4; +var ExportCanvasExtension = class extends CanvasExtension { + isEnabled() { + return "betterExportFeatureEnabled"; + } + init() { + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-breakpoint-changed", + (canvas, node, breakpointRef) => { + if (canvas.screenshotting) breakpointRef.value = true; + } + )); + this.plugin.addCommand({ + id: "export-all-as-image", + name: "Export canvas as image", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (canvas) => canvas.nodes.size > 0, + (canvas) => this.showExportImageSettingsModal(canvas, null) + ) + }); + this.plugin.addCommand({ + id: "export-selected-as-image", + name: "Export selected nodes as image", + checkCallback: CanvasHelper.canvasCommand( + this.plugin, + (canvas) => canvas.selection.size > 0, + (canvas) => this.showExportImageSettingsModal( + canvas, + canvas.getSelectionData().nodes.map((nodeData) => canvas.nodes.get(nodeData.id)).filter((node) => node !== void 0) + ) + ) + }); + } + async showExportImageSettingsModal(canvas, nodesToExport) { + const modal = new import_obsidian18.Modal(this.plugin.app); + modal.setTitle("Export image settings"); + let pixelRatioSetting = null; + let noFontExportSetting = null; + let transparentBackgroundSetting = null; + const updateDynamicSettings = () => { + var _a, _b, _c, _d, _e, _f; + if (svg) { + (_a = pixelRatioSetting == null ? void 0 : pixelRatioSetting.settingEl) == null ? void 0 : _a.hide(); + (_b = noFontExportSetting == null ? void 0 : noFontExportSetting.settingEl) == null ? void 0 : _b.show(); + (_c = transparentBackgroundSetting == null ? void 0 : transparentBackgroundSetting.settingEl) == null ? void 0 : _c.hide(); + } else { + (_d = pixelRatioSetting == null ? void 0 : pixelRatioSetting.settingEl) == null ? void 0 : _d.show(); + (_e = noFontExportSetting == null ? void 0 : noFontExportSetting.settingEl) == null ? void 0 : _e.hide(); + (_f = transparentBackgroundSetting == null ? void 0 : transparentBackgroundSetting.settingEl) == null ? void 0 : _f.show(); + } + }; + let svg = false; + new import_obsidian18.Setting(modal.contentEl).setName("Export file format").setDesc("Choose the file format to export the canvas as.").addDropdown( + (dropdown) => dropdown.addOptions({ + png: "PNG", + svg: "SVG" + }).setValue(svg ? "svg" : "png").onChange((value) => { + svg = value === "svg"; + updateDynamicSettings(); + }) + ); + let pixelRatioFactor = 1; + pixelRatioSetting = new import_obsidian18.Setting(modal.contentEl).setName("Pixel ratio").setDesc("Higher pixel ratios result in higher resolution images but also larger file sizes.").addSlider( + (slider) => slider.setDynamicTooltip().setLimits(0.2, 5, 0.1).setValue(pixelRatioFactor).onChange((value) => pixelRatioFactor = value) + ); + let noFontExport = true; + noFontExportSetting = new import_obsidian18.Setting(modal.contentEl).setName("Skip font export").setDesc("This will not include the fonts in the exported SVG. This will make the SVG file smaller.").addToggle( + (toggle) => toggle.setValue(noFontExport).onChange((value) => noFontExport = value) + ); + let theme = document.body.classList.contains("theme-dark") ? "dark" : "light"; + new import_obsidian18.Setting(modal.contentEl).setName("Theme").setDesc("The theme used for the export.").addDropdown( + (dropdown) => dropdown.addOptions({ + light: "Light", + dark: "Dark" + }).setValue(theme).onChange((value) => theme = value) + ); + let watermark = false; + new import_obsidian18.Setting(modal.contentEl).setName("Show logo").setDesc("This will add an Obsidian + Advanced Canvas logo to the bottom left.").addToggle( + (toggle) => toggle.setValue(watermark).onChange((value) => watermark = value) + ); + let garbledText = false; + new import_obsidian18.Setting(modal.contentEl).setName("Privacy mode").setDesc("This will obscure any text on your canvas.").addToggle( + (toggle) => toggle.setValue(garbledText).onChange((value) => garbledText = value) + ); + let transparentBackground = false; + transparentBackgroundSetting = new import_obsidian18.Setting(modal.contentEl).setName("Transparent background").setDesc("This will make the background of the image transparent.").addToggle( + (toggle) => toggle.setValue(transparentBackground).onChange((value) => transparentBackground = value) + ); + new import_obsidian18.Setting(modal.contentEl).addButton( + (button) => button.setButtonText("Save").setCta().onClick(async () => { + modal.close(); + this.exportImage( + canvas, + nodesToExport, + svg, + svg ? 1 : pixelRatioFactor, + svg ? noFontExport : false, + theme, + watermark, + garbledText, + svg ? true : transparentBackground + ); + }) + ); + updateDynamicSettings(); + modal.open(); + } + async exportImage(canvas, nodesToExport, svg, pixelRatioFactor, noFontExport, theme, watermark, garbledText, transparentBackground) { + var _a, _b, _c; + const cachedTheme = document.body.classList.contains("theme-dark") ? "dark" : "light"; + if (theme !== cachedTheme) { + document.body.classList.toggle("theme-dark", theme === "dark"); + document.body.classList.toggle("theme-light", theme === "light"); + } + const isWholeCanvas = nodesToExport === null; + if (!nodesToExport) nodesToExport = [...canvas.nodes.values()]; + const nodesToExportIds = nodesToExport.map((node) => node.getData().id); + const edgesToExport = [...canvas.edges.values()].filter((edge) => { + const edgeData = edge.getData(); + return nodesToExportIds.includes(edgeData.fromNode) && nodesToExportIds.includes(edgeData.toNode); + }); + const backgroundColor = transparentBackground ? void 0 : window.getComputedStyle(canvas.canvasEl).getPropertyValue("--canvas-background"); + new import_obsidian18.Notice("Exporting the canvas. Please wait..."); + const interactionBlocker = this.getInteractionBlocker(); + document.body.appendChild(interactionBlocker); + canvas.screenshotting = true; + canvas.canvasEl.classList.add("is-exporting"); + if (garbledText) canvas.canvasEl.classList.add("is-text-garbled"); + let watermarkEl = null; + const cachedSelection = new Set(canvas.selection); + canvas.deselectAll(); + const cachedViewport = { x: canvas.x, y: canvas.y, zoom: canvas.zoom }; + try { + const targetBoundingBox = CanvasHelper.getBBox([...nodesToExport, ...edgesToExport]); + let enlargedTargetBoundingBox = BBoxHelper.scaleBBox(targetBoundingBox, 1.1); + const enlargedTargetBoundingBoxSize = { width: enlargedTargetBoundingBox.maxX - enlargedTargetBoundingBox.minX, height: enlargedTargetBoundingBox.maxY - enlargedTargetBoundingBox.minY }; + const canvasElSize = { width: canvas.canvasEl.clientWidth, height: canvas.canvasEl.clientHeight }; + const requiredPixelRatio = Math.max(enlargedTargetBoundingBoxSize.width / canvasElSize.width, enlargedTargetBoundingBoxSize.height / canvasElSize.height); + const pixelRatio = svg ? void 0 : Math.round(requiredPixelRatio * pixelRatioFactor); + watermarkEl = watermark ? this.getWatermark(enlargedTargetBoundingBox) : null; + if (watermarkEl) canvas.canvasEl.appendChild(watermarkEl); + const actualAspectRatio = canvas.canvasRect.width / canvas.canvasRect.height; + const targetAspectRatio = (enlargedTargetBoundingBox.maxX - enlargedTargetBoundingBox.minX) / (enlargedTargetBoundingBox.maxY - enlargedTargetBoundingBox.minY); + let adjustedBoundingBox = { ...enlargedTargetBoundingBox }; + if (actualAspectRatio > targetAspectRatio) { + const targetHeight = enlargedTargetBoundingBox.maxY - enlargedTargetBoundingBox.minY; + const actualWidth = targetHeight * actualAspectRatio; + adjustedBoundingBox.maxX = enlargedTargetBoundingBox.minX + actualWidth; + } else { + const targetWidth = enlargedTargetBoundingBox.maxX - enlargedTargetBoundingBox.minX; + const actualHeight = targetWidth / actualAspectRatio; + adjustedBoundingBox.maxY = enlargedTargetBoundingBox.minY + actualHeight; + } + canvas.zoomToRealBbox(adjustedBoundingBox); + canvas.setViewport(canvas.tx, canvas.ty, canvas.tZoom); + await sleep(10); + let canvasScale = parseFloat(((_a = canvas.canvasEl.style.transform.match(/scale\((\d+(\.\d+)?)\)/)) == null ? void 0 : _a[1]) || "1"); + const edgePathsBBox = BBoxHelper.combineBBoxes(edgesToExport.map((edge) => { + const edgeCenter = edge.getCenter(); + const labelWidth = edge.labelElement ? edge.labelElement.wrapperEl.getBoundingClientRect().width / canvasScale : 0; + return { minX: edgeCenter.x - labelWidth / 2, minY: edgeCenter.y, maxX: edgeCenter.x + labelWidth / 2, maxY: edgeCenter.y }; + })); + const enlargedEdgePathsBBox = BBoxHelper.enlargeBBox(edgePathsBBox, 1.1); + enlargedTargetBoundingBox = BBoxHelper.combineBBoxes([enlargedTargetBoundingBox, enlargedEdgePathsBBox]); + adjustedBoundingBox = BBoxHelper.combineBBoxes([adjustedBoundingBox, enlargedEdgePathsBBox]); + canvas.zoomToRealBbox(adjustedBoundingBox); + canvas.setViewport(canvas.tx, canvas.ty, canvas.tZoom); + await sleep(10); + const canvasViewportBBox = canvas.getViewportBBox(); + canvasScale = parseFloat(((_b = canvas.canvasEl.style.transform.match(/scale\((\d+(\.\d+)?)\)/)) == null ? void 0 : _b[1]) || "1"); + let width = (canvasViewportBBox.maxX - canvasViewportBBox.minX) * canvasScale; + let height = (canvasViewportBBox.maxY - canvasViewportBBox.minY) * canvasScale; + if (actualAspectRatio > targetAspectRatio) + width = height * targetAspectRatio; + else height = width / targetAspectRatio; + let unloadedNodes = nodesToExport.filter((node) => node.initialized === false || node.isContentMounted === false); + const startTimestamp = performance.now(); + while (unloadedNodes.length > 0 && performance.now() - startTimestamp < MAX_ALLOWED_LOADING_TIME) { + await sleep(10); + unloadedNodes = nodesToExport.filter((node) => node.initialized === false || node.isContentMounted === false); + console.info(`Waiting for ${unloadedNodes.length} nodes to finish loading...`); + } + if (unloadedNodes.length === 0) { + const nodeElements = nodesToExport.map((node) => node.nodeEl); + const edgePathAndArrowElements = edgesToExport.map((edge) => [edge.lineGroupEl, edge.lineEndGroupEl]).flat(); + const edgeLabelElements = edgesToExport.map((edge) => { + var _a2; + return (_a2 = edge.labelElement) == null ? void 0 : _a2.wrapperEl; + }).filter((labelElement) => labelElement !== void 0); + const filter = (element) => { + var _a2, _b2, _c2, _d; + if (((_a2 = element.classList) == null ? void 0 : _a2.contains("canvas-node")) && !nodeElements.includes(element)) + return false; + if (((_c2 = (_b2 = element.parentElement) == null ? void 0 : _b2.classList) == null ? void 0 : _c2.contains("canvas-edges")) && !edgePathAndArrowElements.includes(element)) + return false; + if (((_d = element.classList) == null ? void 0 : _d.contains("canvas-path-label-wrapper")) && !edgeLabelElements.includes(element)) + return false; + return true; + }; + const options = { + pixelRatio, + backgroundColor, + height, + width, + filter + }; + if (noFontExport) options.fontEmbedCSS = ""; + let imageDataUri = svg ? await toSvg(canvas.canvasEl, options) : await toPng(canvas.canvasEl, options); + if (svg) { + const header = ``; + imageDataUri = imageDataUri.replace( + encodeURIComponent(" canvas.selection = cachedSelection); + canvas.setViewport(cachedViewport.x, cachedViewport.y, cachedViewport.zoom); + interactionBlocker.remove(); + if (theme !== cachedTheme) { + document.body.classList.toggle("theme-dark", cachedTheme === "dark"); + document.body.classList.toggle("theme-light", cachedTheme === "light"); + } + } + } + getInteractionBlocker() { + const interactionBlocker = document.createElement("div"); + interactionBlocker.classList.add("progress-bar-container"); + const progressBar = document.createElement("div"); + progressBar.classList.add("progress-bar"); + interactionBlocker.appendChild(progressBar); + const progressBarMessage = document.createElement("div"); + progressBarMessage.classList.add("progress-bar-message", "u-center-text"); + progressBarMessage.innerText = "Generating image..."; + progressBar.appendChild(progressBarMessage); + const progressBarIndicator = document.createElement("div"); + progressBarIndicator.classList.add("progress-bar-indicator"); + progressBar.appendChild(progressBarIndicator); + const progressBarLine = document.createElement("div"); + progressBarLine.classList.add("progress-bar-line"); + progressBarIndicator.appendChild(progressBarLine); + const progressBarSublineIncrease = document.createElement("div"); + progressBarSublineIncrease.classList.add("progress-bar-subline", "mod-increase"); + progressBarIndicator.appendChild(progressBarSublineIncrease); + const progressBarSublineDecrease = document.createElement("div"); + progressBarSublineDecrease.classList.add("progress-bar-subline", "mod-decrease"); + progressBarIndicator.appendChild(progressBarSublineDecrease); + return interactionBlocker; + } + getWatermark(bbox) { + const bboxWidth = bbox.maxX - bbox.minX; + const width = Math.max(200, bboxWidth * 0.3); + const WATERMARK_SIZE = { width: 215, height: 25 }; + const height = WATERMARK_SIZE.height / WATERMARK_SIZE.width * width; + const watermarkPadding = { + x: bboxWidth * 0.02, + y: bboxWidth * 0.014 + }; + bbox.maxY += height + watermarkPadding.y; + const watermarkEl = document.createElementNS("http://www.w3.org/2000/svg", "svg"); + watermarkEl.id = "watermark-ac"; + watermarkEl.style.transform = `translate(${bbox.minX + watermarkPadding.x}px, ${bbox.maxY - height - watermarkPadding.y}px)`; + watermarkEl.setAttrs({ + viewBox: `0 0 ${WATERMARK_SIZE.width} ${WATERMARK_SIZE.height}`, + width: width.toString(), + fill: "currentColor" + }); + watermarkEl.innerHTML = ''; + return watermarkEl; + } +}; + +// src/canvas-extensions/floating-edge-canvas-extension.ts +var FloatingEdgeCanvasExtension = class extends CanvasExtension { + isEnabled() { + return "floatingEdgeFeatureEnabled"; + } + init() { + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:data-loaded:after", + (canvas, data, setData) => this.onLoadData(canvas, data) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-moved", + (canvas, node) => this.onNodeMoved(canvas, node) + )); + if (this.plugin.settings.getSetting("allowFloatingEdgeCreation")) { + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:edge-connection-dragging:before", + (canvas, edge, event, newEdge, side) => this.onEdgeStartedDragging(canvas, edge, event, newEdge, side) + )); + } + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:edge-connection-dragging:after", + (canvas, edge, event, newEdge, side) => this.onEdgeStoppedDragging(canvas, edge, event, newEdge, side) + )); + } + onLoadData(canvas, data) { + for (const edgeData of data.edges) { + const edge = canvas.edges.get(edgeData.id); + if (!edge) return console.warn("Imported edge is not yet loaded :("); + this.updateEdgeConnectionSide(edge); + } + } + onNodeMoved(canvas, node) { + const affectedEdges = canvas.getEdgesForNode(node); + for (const edge of affectedEdges) + this.updateEdgeConnectionSide(edge); + } + updateEdgeConnectionSide(edge) { + const edgeData = edge.getData(); + if (edgeData.fromFloating) { + const fixedNodeConnectionPoint = BBoxHelper.getCenterOfBBoxSide(edge.to.node.getBBox(), edge.to.side); + const bestSide = CanvasHelper.getBestSideForFloatingEdge(fixedNodeConnectionPoint, edge.from.node); + if (bestSide !== edge.from.side) { + edge.setData({ + ...edgeData, + fromSide: bestSide + }); + } + } + if (edgeData.toFloating) { + const fixedNodeConnectionPoint = BBoxHelper.getCenterOfBBoxSide(edge.from.node.getBBox(), edge.from.side); + const bestSide = CanvasHelper.getBestSideForFloatingEdge(fixedNodeConnectionPoint, edge.to.node); + if (bestSide !== edge.to.side) { + edge.setData({ + ...edgeData, + toSide: bestSide + }); + } + } + } + onEdgeStartedDragging(canvas, edge, _event, newEdge, _side) { + if (newEdge && this.plugin.settings.getSetting("newEdgeFromSideFloating")) edge.setData({ + ...edge.getData(), + fromFloating: true + // New edges can only get dragged from the "from" side + }); + let cachedViewportNodes = null; + let hasNaNFloatingEdgeDropZones = false; + this.onPointerMove = (event) => { + if (cachedViewportNodes === null || hasNaNFloatingEdgeDropZones || canvas.viewportChanged) { + hasNaNFloatingEdgeDropZones = false; + cachedViewportNodes = canvas.getViewportNodes().map((node) => { + const nodeFloatingEdgeDropZone = this.getFloatingEdgeDropZoneForNode(node); + if (isNaN(nodeFloatingEdgeDropZone.minX) || isNaN(nodeFloatingEdgeDropZone.minY) || isNaN(nodeFloatingEdgeDropZone.maxX) || isNaN(nodeFloatingEdgeDropZone.maxY)) + hasNaNFloatingEdgeDropZones = true; + return [node, nodeFloatingEdgeDropZone]; + }); + } + for (const [node, nodeFloatingEdgeDropZoneClientRect] of cachedViewportNodes) { + const hovering = BBoxHelper.insideBBox({ x: event.clientX, y: event.clientY }, nodeFloatingEdgeDropZoneClientRect, true); + node.nodeEl.classList.toggle("hovering-floating-edge-zone", hovering); + } + }; + document.addEventListener("pointermove", this.onPointerMove); + } + onEdgeStoppedDragging(_canvas, edge, event, _newEdge, side) { + document.removeEventListener("pointermove", this.onPointerMove); + const dropZoneNode = side === "from" ? edge.from.node : edge.to.node; + const floatingEdgeDropZone = this.getFloatingEdgeDropZoneForNode(dropZoneNode); + const wasDroppedInFloatingEdgeDropZone = this.plugin.settings.getSetting("allowFloatingEdgeCreation") ? BBoxHelper.insideBBox({ x: event.clientX, y: event.clientY }, floatingEdgeDropZone, true) : false; + const edgeData = edge.getData(); + if (side === "from" && wasDroppedInFloatingEdgeDropZone == edgeData.fromFloating) return; + if (side === "to" && wasDroppedInFloatingEdgeDropZone == edgeData.toFloating) return; + if (side === "from") edgeData.fromFloating = wasDroppedInFloatingEdgeDropZone; + else edgeData.toFloating = wasDroppedInFloatingEdgeDropZone; + edge.setData(edgeData); + this.updateEdgeConnectionSide(edge); + } + getFloatingEdgeDropZoneForNode(node) { + const nodeElClientBoundingRect = node.nodeEl.getBoundingClientRect(); + const nodeFloatingEdgeDropZoneElStyle = window.getComputedStyle(node.nodeEl, ":after"); + const nodeFloatingEdgeDropZoneSize = { + width: parseFloat(nodeFloatingEdgeDropZoneElStyle.getPropertyValue("width")), + height: parseFloat(nodeFloatingEdgeDropZoneElStyle.getPropertyValue("height")) + }; + return { + minX: nodeElClientBoundingRect.left + (nodeElClientBoundingRect.width - nodeFloatingEdgeDropZoneSize.width) / 2, + minY: nodeElClientBoundingRect.top + (nodeElClientBoundingRect.height - nodeFloatingEdgeDropZoneSize.height) / 2, + maxX: nodeElClientBoundingRect.right - (nodeElClientBoundingRect.width - nodeFloatingEdgeDropZoneSize.width) / 2, + maxY: nodeElClientBoundingRect.bottom - (nodeElClientBoundingRect.height - nodeFloatingEdgeDropZoneSize.height) / 2 + }; + } +}; + +// src/canvas-extensions/edge-highlight-canvas-extension.ts +var EdgeHighlightCanvasExtension = class extends CanvasExtension { + isEnabled() { + return "edgeHighlightEnabled"; + } + init() { + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:selection-changed", + (canvas, oldSelection, updateSelection) => this.onSelectionChanged(canvas, oldSelection) + )); + } + onSelectionChanged(canvas, oldSelection) { + var _a, _b, _c, _d, _e; + const connectedEdgesToBeHighlighted = new Set(canvas.getSelectionData().nodes.flatMap((nodeData) => { + var _a2, _b2; + return [ + ...(_a2 = canvas.edgeFrom.get(canvas.nodes.get(nodeData.id))) != null ? _a2 : [], + ...this.plugin.settings.getSetting("highlightIncomingEdges") ? (_b2 = canvas.edgeTo.get(canvas.nodes.get(nodeData.id))) != null ? _b2 : [] : [] + ]; + })); + for (const edge of canvas.edges.values()) { + const isFocused = canvas.selection.has(edge) || connectedEdgesToBeHighlighted.has(edge); + edge.lineGroupEl.classList.toggle("is-focused", isFocused); + (_b = (_a = edge.lineEndGroupEl) == null ? void 0 : _a.classList) == null ? void 0 : _b.toggle("is-focused", isFocused); + (_e = (_d = (_c = edge.labelElement) == null ? void 0 : _c.textareaEl) == null ? void 0 : _d.classList) == null ? void 0 : _e.toggle("is-focused", isFocused); + } + } +}; + +// src/canvas-extensions/dataset-exposers/canvas-metadata-exposer.ts +var CanvasMetadataExposerExtension = class extends CanvasExtension { + isEnabled() { + return true; + } + init() { + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:canvas-metadata-changed", + (canvas) => this.updateExposedSettings(canvas) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:canvas-changed", + (canvas) => this.updateExposedSettings(canvas) + )); + } + updateExposedSettings(canvas) { + const startNodeId = canvas.metadata["startNode"]; + for (const [nodeId, node] of canvas.nodes) { + if (nodeId === startNodeId) node.nodeEl.dataset.isStartNode = "true"; + else delete node.nodeEl.dataset.isStartNode; + } + } +}; + +// src/canvas-extensions/dataset-exposers/node-exposer.ts +var CANVAS_NODE_IFRAME_BODY_CLASS = "canvas-node-iframe-body"; +function getExposedNodeData(settings) { + const exposedData = []; + if (settings.getSetting("nodeStylingFeatureEnabled")) exposedData.push("styleAttributes"); + if (settings.getSetting("collapsibleGroupsFeatureEnabled")) exposedData.push("collapsed"); + if (settings.getSetting("portalsFeatureEnabled")) exposedData.push("isPortalLoaded"); + return exposedData; +} +var NodeExposerExtension = class extends CanvasExtension { + isEnabled() { + return true; + } + init() { + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-changed", + (_canvas, node) => { + var _a, _b; + const nodeData = node == null ? void 0 : node.getData(); + if (!nodeData) return; + this.setDataAttributes(node.nodeEl, nodeData); + const iframe = (_b = (_a = node.nodeEl.querySelector("iframe")) == null ? void 0 : _a.contentDocument) == null ? void 0 : _b.body; + if (iframe) this.setDataAttributes(iframe, nodeData); + } + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-editing-state-changed", + (_canvas, node, editing) => { + var _a, _b; + if (!editing) return; + const nodeData = node.getData(); + if (!nodeData) return; + const iframe = (_b = (_a = node.nodeEl.querySelector("iframe")) == null ? void 0 : _a.contentDocument) == null ? void 0 : _b.body; + if (!iframe) return; + iframe.classList.add(CANVAS_NODE_IFRAME_BODY_CLASS); + new MutationObserver(() => iframe.classList.toggle(CANVAS_NODE_IFRAME_BODY_CLASS, true)).observe(iframe, { attributes: true, attributeFilter: ["class"] }); + this.setDataAttributes(iframe, nodeData); + } + )); + } + setDataAttributes(element, nodeData) { + for (const exposedDataKey of getExposedNodeData(this.plugin.settings)) { + const datasetPairs = nodeData[exposedDataKey] && typeof nodeData[exposedDataKey] === "object" ? Object.entries(nodeData[exposedDataKey]) : [[exposedDataKey, nodeData[exposedDataKey]]]; + for (const [key, value] of datasetPairs) { + if (!value) delete element.dataset[key]; + else element.dataset[key] = value; + } + } + } +}; + +// src/canvas-extensions/dataset-exposers/node-interaction-exposer.ts +var TARGET_NODE_DATASET_PREFIX = "target"; +var NodeInteractionExposerExtension = class extends CanvasExtension { + isEnabled() { + return true; + } + init() { + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:node-interaction", + (canvas, node) => { + const nodeData = node == null ? void 0 : node.getData(); + if (!nodeData) return; + const interactionEl = canvas.nodeInteractionLayer.interactionEl; + if (!interactionEl) return; + for (const exposedDataKey of getExposedNodeData(this.plugin.settings)) { + const datasetPairs = nodeData[exposedDataKey] instanceof Object ? Object.entries(nodeData[exposedDataKey]) : [[exposedDataKey, nodeData[exposedDataKey]]]; + for (const [key, value] of datasetPairs) { + const modifiedKey = TARGET_NODE_DATASET_PREFIX + key.toString().charAt(0).toUpperCase() + key.toString().slice(1); + if (!value) delete interactionEl.dataset[modifiedKey]; + else interactionEl.dataset[modifiedKey] = value; + } + } + if (PortalsCanvasExtension.isPortalElement(node.id)) interactionEl.dataset.isFromPortal = "true"; + else delete interactionEl.dataset.isFromPortal; + } + )); + } +}; + +// src/canvas-extensions/dataset-exposers/edge-exposer.ts +function getExposedEdgeData(settings) { + const exposedData = []; + if (settings.getSetting("edgesStylingFeatureEnabled")) exposedData.push("styleAttributes"); + return exposedData; +} +var EdgeExposerExtension = class extends CanvasExtension { + isEnabled() { + return true; + } + init() { + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:edge-changed", + (_canvas, edge) => { + var _a, _b, _c, _d; + const edgeData = edge == null ? void 0 : edge.getData(); + if (!edgeData) return; + for (const exposedDataKey of getExposedEdgeData(this.plugin.settings)) { + const datasetPairs = edgeData[exposedDataKey] && typeof edgeData[exposedDataKey] === "object" ? Object.entries(edgeData[exposedDataKey]) : [[exposedDataKey, edgeData[exposedDataKey]]]; + for (const [key, value] of datasetPairs) { + const stringifiedKey = key == null ? void 0 : key.toString(); + if (!stringifiedKey) continue; + if (!value) { + delete edge.path.display.dataset[stringifiedKey]; + if ((_a = edge.fromLineEnd) == null ? void 0 : _a.el) delete edge.fromLineEnd.el.dataset[stringifiedKey]; + if ((_b = edge.toLineEnd) == null ? void 0 : _b.el) delete edge.toLineEnd.el.dataset[stringifiedKey]; + } else { + edge.path.display.dataset[stringifiedKey] = value.toString(); + if ((_c = edge.fromLineEnd) == null ? void 0 : _c.el) edge.fromLineEnd.el.dataset[stringifiedKey] = value.toString(); + if ((_d = edge.toLineEnd) == null ? void 0 : _d.el) edge.toLineEnd.el.dataset[stringifiedKey] = value.toString(); + } + } + } + } + )); + } +}; + +// src/canvas-extensions/dataset-exposers/canvas-wrapper-exposer.ts +var EXPOSED_SETTINGS = [ + "disableFontSizeRelativeToZoom", + "hideBackgroundGridWhenInReadonly", + "collapsibleGroupsFeatureEnabled", + "collapsedGroupPreviewOnDrag", + "allowFloatingEdgeCreation" +]; +var CanvasWrapperExposerExtension = class extends CanvasExtension { + isEnabled() { + return true; + } + init() { + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:settings-changed", + () => this.updateExposedSettings(this.plugin.getCurrentCanvas()) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:canvas-changed", + (canvas) => this.updateExposedSettings(canvas) + )); + this.plugin.registerEvent(this.plugin.app.workspace.on( + "advanced-canvas:dragging-state-changed", + (canvas, dragging) => { + if (dragging) canvas.wrapperEl.dataset.isDragging = "true"; + else delete canvas.wrapperEl.dataset.isDragging; + } + )); + } + updateExposedSettings(canvas) { + if (!canvas) return; + for (const setting of EXPOSED_SETTINGS) { + canvas.wrapperEl.dataset[setting] = this.plugin.settings.getSetting(setting).toString(); + } + } +}; + +// src/patchers/bases-table-view-patcher.ts +var BasesTableViewPatcher = class extends Patcher { + async patch() { + if (!this.plugin.settings.getSetting("canvasMetadataCompatibilityEnabled")) return; + const bases = this.plugin.app.internalPlugins.getEnabledPluginById("bases"); + if (!bases) return; + this.patchViewFactory(bases); + } + async patchViewFactory(bases) { + const that = this; + await Patcher.patchOnce(this.plugin, bases.registrations.table, (resolve) => ({ + factory: Patcher.OverrideExisting((next) => function(...args) { + const view = next.call(this, ...args); + that.patchTableView(view); + resolve(view); + return view; + }) + })); + } + async patchTableView(basesView) { + const that = this; + await Patcher.patchOnce(this.plugin, basesView, (resolve) => ({ + updateVirtualDisplay: Patcher.OverrideExisting((next) => function(...args) { + const result = next.call(this, ...args); + if (this.rows.length > 0) { + const row = this.rows.first(); + that.patchTableRow(row); + resolve(row); + } + return result; + }) + })); + } + async patchTableRow(row) { + const that = this; + await Patcher.patchOnce(this.plugin, row, (resolve) => ({ + render: Patcher.OverrideExisting((next) => function(...args) { + let result = next.call(this, ...args); + if (this.cells.length > 0) { + const cell = this.cells.first(); + that.patchTableCell(cell); + resolve(cell); + result = next.call(this, ...args); + } + return result; + }) + })); + } + async patchTableCell(cell) { + Patcher.patchPrototype(this.plugin, cell, { + render: Patcher.OverrideExisting((next) => function(ctx) { + var _a; + const isCanvas = ((_a = ctx.file) == null ? void 0 : _a.extension) === "canvas"; + if (isCanvas) ctx.file.extension = "md"; + const result = next.call(this, ctx); + if (isCanvas) ctx.file.extension = "canvas"; + return result; + }) + }); + } +}; + +// src/main.ts +var PATCHERS = [ + // Core canvas patchers + CanvasPatcher, + SearchCommandPatcher, + // Core metadata patchers + MetadataCachePatcher, + FileManagerPatcher, + // Direct metadata dependant patchers + PropertiesPatcher, + !(0, import_obsidian19.requireApiVersion)("1.12.0") && BacklinksPatcher, + OutgoingLinksPatcher, + // Metadata dependant patchers + (0, import_obsidian19.requireApiVersion)("1.9.0") && BasesTableViewPatcher, + LinkSuggestionsPatcher, + EmbedPatcher, + SearchPatcher +]; +var CANVAS_EXTENSIONS = [ + // Advanced JSON Canvas Extensions + MetadataCanvasExtension, + NodeStylesExtension, + EdgeStylesExtension, + NodeRatioCanvasExtension, + FloatingEdgeCanvasExtension, + AutoResizeNodeCanvasExtension, + CollapsibleGroupsCanvasExtension, + ColorPaletteCanvasExtension, + PresentationCanvasExtension, + PortalsCanvasExtension, + // UI Extensions (Non-savable data) + CanvasMetadataExposerExtension, + CanvasWrapperExposerExtension, + NodeExposerExtension, + EdgeExposerExtension, + NodeInteractionExposerExtension, + FrontmatterControlButtonCanvasExtension, + BetterDefaultSettingsCanvasExtension, + CommandsCanvasExtension, + BetterReadonlyCanvasExtension, + GroupCanvasExtension, + VariableBreakpointCanvasExtension, + EdgeHighlightCanvasExtension, + AutoFileNodeEdgesCanvasExtension, + FlipEdgeCanvasExtension, + ZOrderingCanvasExtension, + ExportCanvasExtension, + FocusModeCanvasExtension, + EncapsulateCanvasExtension, + EdgeSelectionCanvasExtension +]; +var AdvancedCanvasPlugin = class extends import_obsidian19.Plugin { + async onload() { + IconsHelper.addIcons(); + this.settings = new SettingsManager(this); + await this.settings.loadSettings(); + this.settings.addSettingsTab(); + this.windowsManager = new WindowsManager(this); + this.patchers = PATCHERS.map((Patcher2) => { + if (!Patcher2) return; + try { + return new Patcher2(this); + } catch (e) { + console.error(`Error initializing patcher ${Patcher2.name}:`, e); + } + }); + this.canvasExtensions = CANVAS_EXTENSIONS.map((Extension) => { + try { + return new Extension(this); + } catch (e) { + console.error(`Error initializing ac-extension ${Extension.name}:`, e); + } + }); + } + onunload() { + } + getCanvases() { + return this.app.workspace.getLeavesOfType("canvas").map((leaf) => { + var _a; + return (_a = leaf.view) == null ? void 0 : _a.canvas; + }).filter((canvas) => canvas); + } + getCurrentCanvasView() { + const canvasView = this.app.workspace.getActiveViewOfType(import_obsidian19.ItemView); + if ((canvasView == null ? void 0 : canvasView.getViewType()) !== "canvas") return null; + return canvasView; + } + getCurrentCanvas() { + var _a; + return ((_a = this.getCurrentCanvasView()) == null ? void 0 : _a.canvas) || null; + } + createFileSnapshot(path, content) { + var _a; + const fileRecoveryPlugin = (_a = this.app.internalPlugins.plugins["file-recovery"]) == null ? void 0 : _a.instance; + if (!fileRecoveryPlugin) return; + fileRecoveryPlugin.forceAdd(path, content); + } + // this.app.plugins.plugins["advanced-canvas"].enableDebugMode() + enableDebugMode() { + if (this.debugHelper) return; + this.debugHelper = new DebugHelper(this); + } +}; + +/* nosourcemap */ \ No newline at end of file diff --git a/.obsidian/plugins/advanced-canvas/manifest.json b/.obsidian/plugins/advanced-canvas/manifest.json new file mode 100644 index 0000000..4ccc600 --- /dev/null +++ b/.obsidian/plugins/advanced-canvas/manifest.json @@ -0,0 +1,11 @@ +{ + "id": "advanced-canvas", + "name": "Advanced Canvas", + "version": "6.0.1", + "minAppVersion": "1.1.0", + "description": "Supercharge your canvas experience! Create presentations, flowcharts and more!", + "author": "Developer-Mike", + "authorUrl": "https://github.com/Developer-Mike", + "fundingUrl": "https://ko-fi.com/X8X27IA08", + "isDesktopOnly": false +} diff --git a/.obsidian/plugins/advanced-canvas/styles.css b/.obsidian/plugins/advanced-canvas/styles.css new file mode 100644 index 0000000..2d6b633 --- /dev/null +++ b/.obsidian/plugins/advanced-canvas/styles.css @@ -0,0 +1,508 @@ +/* src/styles.scss */ +.properties-field > .setting-item-info { + flex: 0; + margin: 0; + padding: var(--size-4-1) var(--size-4-2); + border: var(--input-border-width) solid var(--background-modifier-border); + border-radius: var(--input-radius) 0 0 var(--input-radius); +} +.properties-field > .setting-item-control > input { + width: 100%; + border-radius: 0 var(--input-radius) var(--input-radius) 0; +} +.ac-settings-heading:not(:first-child) { + margin-top: var(--size-4-10) !important; +} +.ac-settings-heading:has(.checkbox-container:not(.is-enabled)) { + border-bottom-color: var(--background-modifier-border-hover); +} +.ac-settings-heading .setting-item-description { + margin-inline-end: 20px; +} +.settings-header-children { + transform-origin: top center; + transform: scaleY(1); + transition: transform 0.2s ease-in-out; +} +.settings-header-children details { + flex-direction: column; + align-items: initial; +} +.ac-settings-heading:has(.checkbox-container:not(.is-enabled)) + .settings-header-children { + opacity: 0.5; + pointer-events: none; + height: 0; + transform: scaleY(0); +} +details.setting-item[open] > summary { + margin-bottom: 0.75em; +} +details.setting-item > *:not(summary) { + padding-left: 1em; + border-left: 1px solid var(--color-accent); +} +.kofi-banner { + position: relative; + display: flex; + flex-direction: column; + padding: var(--size-4-3); + background-color: var(--background-secondary); + border: 1px solid var(--divider-color); + border-radius: var(--radius-s); +} +.kofi-banner h1 { + margin: 0; + margin-bottom: 10px; + font-size: var(--font-ui-large); + font-weight: 600; +} +.kofi-banner .progress-container { + display: flex; + flex-direction: row; + align-items: center; + justify-items: center; +} +.kofi-banner .progress-container progress { + background: transparent; +} +.kofi-banner .progress-container progress::-webkit-progress-bar { + background-color: var(--background-modifier-border); + border-radius: var(--input-radius); +} +.kofi-banner .progress-container progress::-webkit-progress-value { + background-color: var(--color-accent); + border-radius: var(--input-radius); +} +.kofi-banner .progress-container .hourly-rate { + margin-left: 10px; + font-weight: 600; +} +.kofi-banner .ac-kofi-button { + align-self: flex-end; + width: min-content; + height: min-content; + line-height: 0; +} +.kofi-banner .ac-kofi-button img { + min-width: 100px; + width: 25%; + max-width: 200px; +} +.canvas-wrapper > .document-search-container { + transform: translateZ(0); + margin: 0; +} +.canvas-wrapper:not(.mod-readonly) .show-while-readonly { + display: none; +} +.canvas-control-item[data-toggled=true] { + background-color: var(--color-accent); +} +.canvas-control-item[data-toggled=true] svg { + stroke: var(--text-on-accent); +} +.reactive-node, +.canvas-node[data-shape=database], +.canvas-node[data-shape=document], +.canvas-node[data-shape=predefined-process], +.canvas-node[data-shape=diamond] { + --border-color: rgb(var(--canvas-color)); + --border-width: 3px; + --box-shadow: none; +} +.reactive-node.is-focused, +.is-focused.canvas-node[data-shape=database], +.is-focused.canvas-node[data-shape=document], +.is-focused.canvas-node[data-shape=predefined-process], +.is-focused.canvas-node[data-shape=diamond], +.reactive-node.is-selected, +.is-selected.canvas-node[data-shape=database], +.is-selected.canvas-node[data-shape=document], +.is-selected.canvas-node[data-shape=predefined-process], +.is-selected.canvas-node[data-shape=diamond] { + --border-color: var(--color-accent); + --border-width: 5px; + --box-shadow: var(--shadow-border-accent); +} +.reactive-node.is-themed, +.is-themed.canvas-node[data-shape=database], +.is-themed.canvas-node[data-shape=document], +.is-themed.canvas-node[data-shape=predefined-process], +.is-themed.canvas-node[data-shape=diamond] { + --border-color: rgba(var(--canvas-color), 0.7); +} +.reactive-node.is-themed.is-focused, +.is-themed.is-focused.canvas-node[data-shape=database], +.is-themed.is-focused.canvas-node[data-shape=document], +.is-themed.is-focused.canvas-node[data-shape=predefined-process], +.is-themed.is-focused.canvas-node[data-shape=diamond], +.reactive-node.is-themed.is-selected, +.is-themed.is-selected.canvas-node[data-shape=database], +.is-themed.is-selected.canvas-node[data-shape=document], +.is-themed.is-selected.canvas-node[data-shape=predefined-process], +.is-themed.is-selected.canvas-node[data-shape=diamond] { + --border-color: rgb(var(--canvas-color)); + --box-shadow: var(--shadow-border-themed); +} +.canvas-node[data-text-align=center] .markdown-preview-view { + scrollbar-gutter: auto; +} +.canvas-node[data-text-align=center] .markdown-preview-view .markdown-preview-section { + display: flex; + flex-direction: column; + justify-content: center; + text-align: center; + vertical-align: middle; +} +.canvas-node[data-text-align=right] { + text-align: right; +} +.canvas-node[data-shape] .canvas-node-container .markdown-preview-view.markdown-rendered { + transform: unset; +} +.canvas-node[data-shape=pill] .canvas-node-container { + border-radius: 5000px; +} +.canvas-node[data-shape=diamond] { +} +.canvas-node[data-shape=diamond].is-focused, +.canvas-node[data-shape=diamond].is-selected { + border-radius: var(--radius-m); + outline: 2px solid var(--color-accent); + outline-offset: 5px; +} +.canvas-node[data-shape=diamond] .canvas-node-container { + border: none; + box-shadow: none !important; +} +.canvas-node[data-shape=diamond] .canvas-node-container:not(:has(.embed-iframe)) { + mask-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 141.42135624 141.42135624' preserveAspectRatio='none'%3E%3Cstyle%3E rect %7B transform-origin: center; transform: rotate(45deg) scale(1.05); %7D %3C/style%3E%3Crect rx='8' x='20.71067812' y='20.71067812' width='100' height='100' /%3E%3C/svg%3E"); + -webkit-mask-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 141.42135624 141.42135624' preserveAspectRatio='none'%3E%3Cstyle%3E rect %7B transform-origin: center; transform: rotate(45deg) scale(1.05); %7D %3C/style%3E%3Crect rx='8' x='20.71067812' y='20.71067812' width='100' height='100' /%3E%3C/svg%3E"); + mask-repeat: no-repeat; + -webkit-mask-repeat: no-repeat; + mask-size: 100%; + -webkit-mask-size: 100%; +} +.canvas-node[data-shape=diamond] .canvas-node-container .canvas-node-placeholder::after { + mask-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 141.42135624 141.42135624' preserveAspectRatio='none'%3E%3Cstyle%3E rect %7B transform-origin: center; transform: rotate(45deg) scale(1.05); %7D %3C/style%3E%3Crect rx='8' x='20.71067812' y='20.71067812' width='100' height='100' /%3E%3C/svg%3E"); + -webkit-mask-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 141.42135624 141.42135624' preserveAspectRatio='none'%3E%3Cstyle%3E rect %7B transform-origin: center; transform: rotate(45deg) scale(1.05); %7D %3C/style%3E%3Crect rx='8' x='20.71067812' y='20.71067812' width='100' height='100' /%3E%3C/svg%3E"); + mask-repeat: no-repeat; + -webkit-mask-repeat: no-repeat; + mask-size: 100%; + -webkit-mask-size: 100%; +} +.canvas-node[data-shape=diamond]::before { + mask-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 141.42135624 141.42135624' preserveAspectRatio='none'%3E%3Cstyle%3E rect %7B transform-origin: center; transform: rotate(45deg) scale(1.05); %7D %3C/style%3E%3Crect rx='8' x='20.71067812' y='20.71067812' width='100' height='100' /%3E%3C/svg%3E"); + -webkit-mask-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 141.42135624 141.42135624' preserveAspectRatio='none'%3E%3Cstyle%3E rect %7B transform-origin: center; transform: rotate(45deg) scale(1.05); %7D %3C/style%3E%3Crect rx='8' x='20.71067812' y='20.71067812' width='100' height='100' /%3E%3C/svg%3E"); + mask-repeat: no-repeat; + -webkit-mask-repeat: no-repeat; + mask-size: 100%; + -webkit-mask-size: 100%; + content: ""; + position: absolute; + top: calc(var(--border-width) * -1); + left: calc(var(--border-width) * -1); + width: calc(100% + var(--border-width) * 2); + height: calc(100% + var(--border-width) * 2); + background-color: var(--border-color); +} +.canvas-node[data-shape=parallelogram] .canvas-node-container { + transform: skewX(-20deg); + backface-visibility: hidden; +} +.canvas-node[data-shape=parallelogram] .canvas-node-container .canvas-node-content .markdown-embed-content { + transform: skewX(20deg); +} +.canvas-node[data-shape=circle] .canvas-node-container { + border-radius: 50%; +} +.canvas-node[data-shape=circle] .canvas-node-container .markdown-preview-view { + overflow-y: initial; +} +.canvas-node[data-shape=predefined-process] .canvas-node-container .canvas-node-content { + padding: 0 10px; +} +.canvas-node[data-shape=predefined-process] .canvas-node-container::before, +.canvas-node[data-shape=predefined-process] .canvas-node-container::after { + content: ""; + z-index: 1; + position: absolute; + top: 0; + width: 0; + height: 100%; + border-left: var(--border-width) solid var(--border-color); +} +.canvas-node[data-shape=predefined-process] .canvas-node-container::before { + left: calc(10px - var(--border-width)); +} +.canvas-node[data-shape=predefined-process] .canvas-node-container::after { + right: calc(10px - var(--border-width)); +} +.canvas-node[data-shape=document] { + --border-width: 2.5px; + filter: drop-shadow(0 var(--border-width) 0 var(--border-color)) drop-shadow(0 calc(var(--border-width) * -1) 0 var(--border-color)); +} +.canvas-node[data-shape=document] .canvas-node-container { + mask-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 75 45' preserveAspectRatio='none'%3E%3Cpath d='M75 0 75 39.375Q56.25 29.25 37.5 39.375 18.75 49.5 0 39.375L0 0Z' /%3E%3C/svg%3E"); + -webkit-mask-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 75 45' preserveAspectRatio='none'%3E%3Cpath d='M75 0 75 39.375Q56.25 29.25 37.5 39.375 18.75 49.5 0 39.375L0 0Z' /%3E%3C/svg%3E"); + mask-repeat: no-repeat; + -webkit-mask-repeat: no-repeat; + mask-size: 100%; + -webkit-mask-size: 100%; + border: var(--border-width) solid var(--border-color); + border-top: none; + border-bottom: none; +} +.canvas-node[data-shape=document].is-focused, +.canvas-node[data-shape=document].is-selected { + --border-width: 4px; +} +.canvas-node[data-shape=database] { +} +.canvas-node[data-shape=database] .canvas-node-container { + border: var(--border-width) solid var(--border-color); + border-bottom: 0; + border-top: 0; + border-radius: 0; + box-shadow: none !important; +} +.canvas-node[data-shape=database] .canvas-node-container .canvas-node-placeholder { + transform: translateY(25px); +} +.canvas-node[data-shape=database]::before, +.canvas-node[data-shape=database]::after { + content: ""; + position: absolute; + left: 0; + box-sizing: border-box; + width: 100%; + height: 50px; + border-radius: 50%; + border: var(--border-width) solid var(--border-color); + background-color: var(--background-primary); +} +.canvas-node[data-shape=database]::after { + top: -25px; +} +.canvas-node[data-shape=database]::before { + bottom: -25px; +} +.canvas-node[data-shape=database].is-themed .canvas-node-content { + background-color: transparent; +} +.canvas-node[data-shape=database].is-themed:not(:has(.embed-iframe)) .canvas-node-container, +.canvas-node[data-shape=database].is-themed:not(:has(.embed-iframe))::after, +.canvas-node[data-shape=database].is-themed:not(:has(.embed-iframe))::before { + box-shadow: inset 0 0 0 1000px rgba(var(--canvas-color), 0.07) !important; +} +.canvas-node[data-shape=database] .canvas-node-content:not(:has(.embed-iframe)) { + transform: translateY(20px); +} +.canvas-node[data-shape=database]:has(.embed-iframe)::after { + z-index: -1; +} +.canvas-node[data-border=dashed] .canvas-node-container { + box-shadow: none; + border-style: dashed; +} +.canvas-node[data-border=dotted] .canvas-node-container { + box-shadow: none; + border-style: dotted; +} +.canvas-node[data-border=invisible] { + box-shadow: none; +} +.canvas-node[data-border=invisible]:not(.is-focused):not(.is-selected) .canvas-node-container { + border-color: transparent !important; +} +.canvas-node[data-border=invisible] .canvas-node-label { + display: none; +} +.canvas-node[data-border=invisible] .canvas-node-container { + background-color: transparent; + box-shadow: none; +} +.canvas-node[data-border][data-shape=predefined-process] { + --border-width: 2px; +} +.canvas-node[data-border][data-shape=predefined-process] .is-focused, +.canvas-node[data-border][data-shape=predefined-process] .is-selected { + --border-width: 2px; +} +.canvas-node[data-border=dashed][data-shape=predefined-process] .canvas-node-container::before, +.canvas-node[data-border=dashed][data-shape=predefined-process] .canvas-node-container::after { + border-left: var(--border-width) dashed var(--border-color); +} +.canvas-node[data-border=dotted][data-shape=predefined-process] .canvas-node-container::before, +.canvas-node[data-border=dotted][data-shape=predefined-process] .canvas-node-container::after { + border-left: var(--border-width) dotted var(--border-color); +} +.canvas-node[data-border][data-shape=document] .canvas-node-container { + border-top: none; + border-bottom: none; +} +.canvas-edges path[data-path=dotted] { + stroke-dasharray: calc(3px * var(--zoom-multiplier)); +} +.canvas-edges path[data-path=short-dashed] { + stroke-dasharray: 9px; +} +.canvas-edges path[data-path=long-dashed] { + stroke-dasharray: 18px; +} +.canvas-edges [data-arrow=triangle-outline] polygon, +.canvas-edges [data-arrow=diamond-outline] polygon, +.canvas-edges [data-arrow=circle-outline] polygon { + fill: var(--canvas-background); + stroke: rgb(var(--canvas-color)); + stroke-width: calc(3px * var(--zoom-multiplier)); +} +.canvas-edges [data-arrow=thin-triangle] polygon { + fill: transparent; + stroke: rgb(var(--canvas-color)); + stroke-width: calc(4px * var(--zoom-multiplier)); +} +.canvas.is-exporting { + --zoom-multiplier: 1; +} +.canvas.is-exporting * { + pointer-events: none !important; + transition: none !important; +} +.canvas.is-exporting .collapse-button { + display: none; +} +.canvas.is-exporting #watermark-ac { + z-index: 9999999; + position: absolute; +} +.canvas-wrapper[data-collapsible-groups-feature-enabled=true] .canvas.is-exporting .canvas-node .canvas-group-label { + left: 0; +} +.progress-bar-modal-ac { + margin-top: 0.75em; +} +.progress-bar-modal-ac.error .setting-progress-bar { + color: var(--color-error); +} +.canvas-wrapper[data-disable-font-size-relative-to-zoom=true] { + --zoom-multiplier: 1 !important; +} +.canvas-wrapper.mod-readonly .canvas-controls .canvas-control-group:nth-child(3), +.canvas-wrapper.mod-readonly .canvas-card-menu { + display: none; +} +.canvas-wrapper.mod-readonly[data-hide-background-grid-when-in-readonly=true] .canvas-background { + visibility: hidden; +} +.collapse-button { + position: absolute; + left: 0; + top: calc(-1 * var(--size-4-1) * var(--zoom-multiplier)); + padding: var(--size-4-1) var(--size-4-2); + transform-origin: bottom left; + transform: translate(0, -100%) scale(var(--zoom-multiplier)); + border-radius: var(--radius-s); + color: var(--text-muted); + background-color: rgba(var(--canvas-color), 0.1); + font-size: 1.5em; + line-height: 1; + pointer-events: initial; + cursor: pointer; + transition: transform 500ms cubic-bezier(0.16, 1, 0.3, 1); +} +.canvas-wrapper[data-collapsible-groups-feature-enabled=true] .canvas-node .canvas-group-label { + left: calc(40px * var(--zoom-multiplier)); +} +.canvas-node[data-collapsed] .canvas-node-container { + display: none; +} +.canvas-node[data-collapsed] .canvas-group-label { + max-width: initial; +} +.canvas-wrapper[data-collapsed-group-preview-on-drag=true][data-is-dragging] .canvas-node[data-collapsed] .canvas-node-container { + display: block; + opacity: 0.5; + border-style: dashed; +} +.canvas-wrapper[data-collapsed-group-preview-on-drag=true][data-is-dragging] .canvas-node[data-collapsed] .canvas-node-container .canvas-node-content { + background-color: transparent; +} +.canvas-node-interaction-layer[data-target-collapsed] .canvas-node-resizer { + pointer-events: none; + cursor: inherit; +} +.canvas-node-interaction-layer[data-target-collapsed] .canvas-node-resizer .canvas-node-connection-point { + display: none; + pointer-events: none; +} +.canvas-wrapper[data-allow-floating-edge-creation=true] .canvas.is-connecting .canvas-node:not(.canvas-node-group)::after { + all: unset; + content: ""; + z-index: 100; + position: absolute; + top: 50%; + left: 50%; + width: max(10px, 100% - 50px * var(--zoom-multiplier) * 2); + height: max(10px, 100% - 50px * var(--zoom-multiplier) * 2); + transform: translate(-50%, -50%); + border-radius: var(--radius-m); + outline: calc(4px * var(--zoom-multiplier)) dashed hsla(var(--color-accent-hsl), 0.5); +} +.canvas-wrapper[data-allow-floating-edge-creation=true] .canvas.is-connecting .canvas-node:not(.canvas-node-group).hovering-floating-edge-zone::after { + outline-color: var(--color-accent); + outline-style: solid; + background-color: hsla(var(--color-accent-hsl), 0.1); +} +.canvas-wrapper[data-focus-mode-enabled=true] .canvas:has(.canvas-node.is-focused) .canvas-node:not(.is-focused) { + filter: blur(5px); +} +.canvas-wrapper[data-focus-mode-enabled=true] .canvas:has(.canvas-node.is-focused) .canvas-edges > g:not(.is-focused) { + filter: blur(5px); +} +.canvas-wrapper[data-focus-mode-enabled=true] .canvas:has(.canvas-node.is-focused) .canvas-path-label-wrapper > .canvas-path-label:not(.is-focused) { + filter: blur(5px); +} +.canvas-wrapper.presentation-mode .canvas-controls { + visibility: hidden; +} +.canvas-wrapper.presentation-mode .canvas-card-menu { + visibility: hidden; +} +.canvas-wrapper:not(.presentation-mode) .canvas-node[data-is-start-node=true]::before { + content: "Start"; + position: absolute; + top: calc(-1 * var(--size-4-1) * var(--zoom-multiplier)); + right: 0; + transform: translate(0, -100%) scale(var(--zoom-multiplier)); + transform-origin: bottom right; + max-width: calc(100% / var(--zoom-multiplier)); + padding: var(--size-4-1) var(--size-4-2); + font-size: 1em; + border-radius: var(--radius-s); + color: var(--color-green); + background-color: rgba(var(--color-green-rgb), 0.1); +} +.canvas-node[data-is-portal-loaded=true] { + pointer-events: all; +} +.canvas-node[data-is-portal-loaded=true]:not(.is-focused) { + pointer-events: none; +} +.canvas-node[data-is-portal-loaded=true]:not(.is-focused) .canvas-node-label { + pointer-events: all; +} +.canvas-node[data-is-portal-loaded=true] .canvas-node-container { + background-color: transparent; + border-style: dashed; +} +.canvas-node[data-is-portal-loaded=true] .canvas-node-container .canvas-node-content { + display: none; +} +.canvas-node-interaction-layer[data-is-from-portal=true] .canvas-node-resizer { + pointer-events: none; + cursor: inherit; +} +.canvas-node-interaction-layer[data-is-from-portal=true] .canvas-node-resizer .canvas-node-connection-point { + pointer-events: all; +} diff --git a/.obsidian/plugins/obsidian-plantuml/main.js b/.obsidian/plugins/obsidian-plantuml/main.js new file mode 100644 index 0000000..16e59b9 --- /dev/null +++ b/.obsidian/plugins/obsidian-plantuml/main.js @@ -0,0 +1,7938 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ESBUILD +if you want to view the source, please visit the github repository of this plugin +https://github.com/joethei/obsidian-plantuml +*/ + +var __create = Object.create; +var __defProp = Object.defineProperty; +var __defProps = Object.defineProperties; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropDescs = Object.getOwnPropertyDescriptors; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + } + return a; +}; +var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); +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 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( + // 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 __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()); + }); +}; + +// node_modules/plantuml-encoder/dist/plantuml-encoder.js +var require_plantuml_encoder = __commonJS({ + "node_modules/plantuml-encoder/dist/plantuml-encoder.js"(exports, module2) { + (function(f) { + if (typeof exports === "object" && typeof module2 !== "undefined") { + module2.exports = f(); + } else if (typeof define === "function" && define.amd) { + define([], f); + } else { + var g; + if (typeof window !== "undefined") { + g = window; + } else if (typeof global !== "undefined") { + g = global; + } else if (typeof self !== "undefined") { + g = self; + } else { + g = this; + } + g.plantumlEncoder = f(); + } + })(function() { + var define2, module3, exports2; + return (/* @__PURE__ */ (function() { + function r(e, n, t) { + function o(i2, f) { + if (!n[i2]) { + if (!e[i2]) { + var c = "function" == typeof require && require; + if (!f && c) return c(i2, true); + if (u) return u(i2, true); + var a = new Error("Cannot find module '" + i2 + "'"); + throw a.code = "MODULE_NOT_FOUND", a; + } + var p = n[i2] = { exports: {} }; + e[i2][0].call(p.exports, function(r2) { + var n2 = e[i2][1][r2]; + return o(n2 || r2); + }, p, p.exports, r, e, n, t); + } + return n[i2].exports; + } + for (var u = "function" == typeof require && require, i = 0; i < t.length; i++) o(t[i]); + return o; + } + return r; + })())({ 1: [function(require2, module4, exports3) { + "use strict"; + var pako = require2("pako/lib/deflate.js"); + module4.exports = function(data) { + return pako.deflateRaw(data, { level: 9, to: "string" }); + }; + }, { "pako/lib/deflate.js": 4 }], 2: [function(require2, module4, exports3) { + "use strict"; + function encode6bit(b) { + if (b < 10) { + return String.fromCharCode(48 + b); + } + b -= 10; + if (b < 26) { + return String.fromCharCode(65 + b); + } + b -= 26; + if (b < 26) { + return String.fromCharCode(97 + b); + } + b -= 26; + if (b === 0) { + return "-"; + } + if (b === 1) { + return "_"; + } + return "?"; + } + function append3bytes(b1, b2, b3) { + var c1 = b1 >> 2; + var c2 = (b1 & 3) << 4 | b2 >> 4; + var c3 = (b2 & 15) << 2 | b3 >> 6; + var c4 = b3 & 63; + var r = ""; + r += encode6bit(c1 & 63); + r += encode6bit(c2 & 63); + r += encode6bit(c3 & 63); + r += encode6bit(c4 & 63); + return r; + } + module4.exports = function(data) { + var r = ""; + for (var i = 0; i < data.length; i += 3) { + if (i + 2 === data.length) { + r += append3bytes(data.charCodeAt(i), data.charCodeAt(i + 1), 0); + } else if (i + 1 === data.length) { + r += append3bytes(data.charCodeAt(i), 0, 0); + } else { + r += append3bytes( + data.charCodeAt(i), + data.charCodeAt(i + 1), + data.charCodeAt(i + 2) + ); + } + } + return r; + }; + }, {}], 3: [function(require2, module4, exports3) { + "use strict"; + var deflate = require2("./deflate"); + var encode64 = require2("./encode64"); + module4.exports.encode = function(puml) { + var deflated = deflate(puml); + return encode64(deflated); + }; + }, { "./deflate": 1, "./encode64": 2 }], 4: [function(require2, module4, exports3) { + "use strict"; + var zlib_deflate = require2("./zlib/deflate"); + var utils = require2("./utils/common"); + var strings = require2("./utils/strings"); + var msg = require2("./zlib/messages"); + var ZStream = require2("./zlib/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 status = zlib_deflate.deflateInit2( + this.strm, + opt.level, + opt.method, + opt.windowBits, + opt.memLevel, + opt.strategy + ); + if (status !== Z_OK) { + throw new Error(msg[status]); + } + 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; + } + status = zlib_deflate.deflateSetDictionary(this.strm, dict); + if (status !== Z_OK) { + throw new Error(msg[status]); + } + this._dict_set = true; + } + } + Deflate.prototype.push = function(data, mode) { + var strm = this.strm; + var chunkSize = this.options.chunkSize; + var status, _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; + } + status = zlib_deflate.deflate(strm, _mode); + if (status !== Z_STREAM_END && status !== Z_OK) { + this.onEnd(status); + 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) && status !== Z_STREAM_END); + if (_mode === Z_FINISH) { + status = zlib_deflate.deflateEnd(this.strm); + this.onEnd(status); + this.ended = true; + return status === 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(status) { + if (status === Z_OK) { + if (this.options.to === "string") { + this.result = this.chunks.join(""); + } else { + this.result = utils.flattenChunks(this.chunks); + } + } + this.chunks = []; + this.err = status; + this.msg = this.strm.msg; + }; + function deflate(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 deflate(input, options); + } + function gzip(input, options) { + options = options || {}; + options.gzip = true; + return deflate(input, options); + } + exports3.Deflate = Deflate; + exports3.deflate = deflate; + exports3.deflateRaw = deflateRaw; + exports3.gzip = gzip; + }, { "./utils/common": 5, "./utils/strings": 6, "./zlib/deflate": 9, "./zlib/messages": 10, "./zlib/zstream": 12 }], 5: [function(require2, module4, exports3) { + "use strict"; + var TYPED_OK = typeof Uint8Array !== "undefined" && typeof Uint16Array !== "undefined" && typeof Int32Array !== "undefined"; + function _has(obj, key) { + return Object.prototype.hasOwnProperty.call(obj, key); + } + exports3.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; + }; + exports3.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); + } + }; + exports3.setTyped = function(on) { + if (on) { + exports3.Buf8 = Uint8Array; + exports3.Buf16 = Uint16Array; + exports3.Buf32 = Int32Array; + exports3.assign(exports3, fnTyped); + } else { + exports3.Buf8 = Array; + exports3.Buf16 = Array; + exports3.Buf32 = Array; + exports3.assign(exports3, fnUntyped); + } + }; + exports3.setTyped(TYPED_OK); + }, {}], 6: [function(require2, module4, exports3) { + "use strict"; + var utils = require2("./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 (var q = 0; q < 256; q++) { + _utf8len[q] = q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1; + } + _utf8len[254] = _utf8len[254] = 1; + exports3.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; + } + exports3.buf2binstring = function(buf) { + return buf2binstring(buf, buf.length); + }; + exports3.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; + }; + exports3.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); + }; + exports3.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; + }; + }, { "./common": 5 }], 7: [function(require2, module4, exports3) { + "use strict"; + 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; + } + module4.exports = adler32; + }, {}], 8: [function(require2, module4, exports3) { + "use strict"; + 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 crc32(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; + } + module4.exports = crc32; + }, {}], 9: [function(require2, module4, exports3) { + "use strict"; + var utils = require2("../utils/common"); + var trees = require2("./trees"); + var adler32 = require2("./adler32"); + var crc32 = require2("./crc32"); + var msg = require2("./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, last) { + trees._tr_flush_block(s, s.block_start >= 0 ? s.block_start : -1, s.strstart - s.block_start, last); + 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 = crc32(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, flush) { + 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 && flush === 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 (flush === 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, flush) { + var hash_head; + var bflush; + for (; ; ) { + if (s.lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s.lookahead < MIN_LOOKAHEAD && flush === 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 (flush === 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, flush) { + var hash_head; + var bflush; + var max_insert; + for (; ; ) { + if (s.lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s.lookahead < MIN_LOOKAHEAD && flush === 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 (flush === 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, flush) { + 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 && flush === 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 (flush === 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, flush) { + var bflush; + for (; ; ) { + if (s.lookahead === 0) { + fill_window(s); + if (s.lookahead === 0) { + if (flush === 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 (flush === 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, method, 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 || method !== 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 = method; + return deflateReset(strm); + } + function deflateInit(strm, level) { + return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY); + } + function deflate(strm, flush) { + var old_flush, s; + var beg, val; + if (!strm || !strm.state || flush > Z_BLOCK || flush < 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 && flush !== 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 = flush; + 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 = crc32(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 = crc32(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 = crc32(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 = crc32(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 = crc32(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 = crc32(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 = crc32(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(flush) <= rank(old_flush) && flush !== 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 || flush !== Z_NO_FLUSH && s.status !== FINISH_STATE) { + var bstate = s.strategy === Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : s.strategy === Z_RLE ? deflate_rle(s, flush) : configuration_table[s.level].func(s, flush); + 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 (flush === Z_PARTIAL_FLUSH) { + trees._tr_align(s); + } else if (flush !== Z_BLOCK) { + trees._tr_stored_block(s, 0, 0, false); + if (flush === 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 (flush !== 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 status; + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + status = strm.state.status; + if (status !== INIT_STATE && status !== EXTRA_STATE && status !== NAME_STATE && status !== COMMENT_STATE && status !== HCRC_STATE && status !== BUSY_STATE && status !== FINISH_STATE) { + return err(strm, Z_STREAM_ERROR); + } + strm.state = null; + return status === 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; + } + exports3.deflateInit = deflateInit; + exports3.deflateInit2 = deflateInit2; + exports3.deflateReset = deflateReset; + exports3.deflateResetKeep = deflateResetKeep; + exports3.deflateSetHeader = deflateSetHeader; + exports3.deflate = deflate; + exports3.deflateEnd = deflateEnd; + exports3.deflateSetDictionary = deflateSetDictionary; + exports3.deflateInfo = "pako deflate (from Nodeca project)"; + }, { "../utils/common": 5, "./adler32": 7, "./crc32": 8, "./messages": 10, "./trees": 11 }], 10: [function(require2, module4, exports3) { + "use strict"; + module4.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) */ + }; + }, {}], 11: [function(require2, module4, exports3) { + "use strict"; + var utils = require2("../utils/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, last) { + send_bits(s, (STORED_BLOCK << 1) + (last ? 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, last) { + 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, last); + } else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) { + send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3); + compress_block(s, static_ltree, static_dtree); + } else { + send_bits(s, (DYN_TREES << 1) + (last ? 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 (last) { + 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; + } + exports3._tr_init = _tr_init; + exports3._tr_stored_block = _tr_stored_block; + exports3._tr_flush_block = _tr_flush_block; + exports3._tr_tally = _tr_tally; + exports3._tr_align = _tr_align; + }, { "../utils/common": 5 }], 12: [function(require2, module4, exports3) { + "use strict"; + 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; + } + module4.exports = ZStream; + }, {}] }, {}, [3])(3); + }); + } +}); + +// node_modules/plantuml-encoder/dist/plantuml-decoder.js +var require_plantuml_decoder = __commonJS({ + "node_modules/plantuml-encoder/dist/plantuml-decoder.js"(exports, module2) { + (function(f) { + if (typeof exports === "object" && typeof module2 !== "undefined") { + module2.exports = f(); + } else if (typeof define === "function" && define.amd) { + define([], f); + } else { + var g; + if (typeof window !== "undefined") { + g = window; + } else if (typeof global !== "undefined") { + g = global; + } else if (typeof self !== "undefined") { + g = self; + } else { + g = this; + } + g.plantumlEncoder = f(); + } + })(function() { + var define2, module3, exports2; + return (/* @__PURE__ */ (function() { + function r(e, n, t) { + function o(i2, f) { + if (!n[i2]) { + if (!e[i2]) { + var c = "function" == typeof require && require; + if (!f && c) return c(i2, true); + if (u) return u(i2, true); + var a = new Error("Cannot find module '" + i2 + "'"); + throw a.code = "MODULE_NOT_FOUND", a; + } + var p = n[i2] = { exports: {} }; + e[i2][0].call(p.exports, function(r2) { + var n2 = e[i2][1][r2]; + return o(n2 || r2); + }, p, p.exports, r, e, n, t); + } + return n[i2].exports; + } + for (var u = "function" == typeof require && require, i = 0; i < t.length; i++) o(t[i]); + return o; + } + return r; + })())({ 1: [function(require2, module4, exports3) { + "use strict"; + var pako = require2("pako/lib/inflate.js"); + module4.exports = function(data) { + return pako.inflateRaw(data, { to: "string" }); + }; + }, { "pako/lib/inflate.js": 4 }], 2: [function(require2, module4, exports3) { + "use strict"; + function decode6bit(cc) { + var c = cc.charCodeAt(0); + if (cc === "_") return 63; + if (cc === "-") return 62; + if (c >= 97) return c - 61; + if (c >= 65) return c - 55; + if (c >= 48) return c - 48; + return "?"; + } + function extract3bytes(data) { + var c1 = decode6bit(data[0]); + var c2 = decode6bit(data[1]); + var c3 = decode6bit(data[2]); + var c4 = decode6bit(data[3]); + var b1 = c1 << 2 | c2 >> 4 & 63; + var b2 = c2 << 4 & 240 | c3 >> 2 & 15; + var b3 = c3 << 6 & 192 | c4 & 63; + return [b1, b2, b3]; + } + module4.exports = function(data) { + var r = ""; + var i = 0; + for (i = 0; i < data.length; i += 4) { + var t = extract3bytes(data.substring(i, i + 4)); + r = r + String.fromCharCode(t[0]); + r = r + String.fromCharCode(t[1]); + r = r + String.fromCharCode(t[2]); + } + return r; + }; + }, {}], 3: [function(require2, module4, exports3) { + "use strict"; + var inflate = require2("./inflate"); + var decode64 = require2("./decode64"); + module4.exports.decode = function(encoded) { + var deflated = decode64(encoded); + return inflate(deflated); + }; + }, { "./decode64": 2, "./inflate": 1 }], 4: [function(require2, module4, exports3) { + "use strict"; + var zlib_inflate = require2("./zlib/inflate"); + var utils = require2("./utils/common"); + var strings = require2("./utils/strings"); + var c = require2("./zlib/constants"); + var msg = require2("./zlib/messages"); + var ZStream = require2("./zlib/zstream"); + var GZheader = require2("./zlib/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 status = zlib_inflate.inflateInit2( + this.strm, + opt.windowBits + ); + if (status !== c.Z_OK) { + throw new Error(msg[status]); + } + 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) { + status = zlib_inflate.inflateSetDictionary(this.strm, opt.dictionary); + if (status !== c.Z_OK) { + throw new Error(msg[status]); + } + } + } + } + Inflate.prototype.push = function(data, mode) { + var strm = this.strm; + var chunkSize = this.options.chunkSize; + var dictionary = this.options.dictionary; + var status, _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; + } + status = zlib_inflate.inflate(strm, c.Z_NO_FLUSH); + if (status === c.Z_NEED_DICT && dictionary) { + status = zlib_inflate.inflateSetDictionary(this.strm, dictionary); + } + if (status === c.Z_BUF_ERROR && allowBufError === true) { + status = c.Z_OK; + allowBufError = false; + } + if (status !== c.Z_STREAM_END && status !== c.Z_OK) { + this.onEnd(status); + this.ended = true; + return false; + } + if (strm.next_out) { + if (strm.avail_out === 0 || status === 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) && status !== c.Z_STREAM_END); + if (status === c.Z_STREAM_END) { + _mode = c.Z_FINISH; + } + if (_mode === c.Z_FINISH) { + status = zlib_inflate.inflateEnd(this.strm); + this.onEnd(status); + this.ended = true; + return status === 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(status) { + if (status === c.Z_OK) { + if (this.options.to === "string") { + this.result = this.chunks.join(""); + } else { + this.result = utils.flattenChunks(this.chunks); + } + } + this.chunks = []; + this.err = status; + this.msg = this.strm.msg; + }; + function inflate(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 inflate(input, options); + } + exports3.Inflate = Inflate; + exports3.inflate = inflate; + exports3.inflateRaw = inflateRaw; + exports3.ungzip = inflate; + }, { "./utils/common": 5, "./utils/strings": 6, "./zlib/constants": 8, "./zlib/gzheader": 10, "./zlib/inflate": 12, "./zlib/messages": 14, "./zlib/zstream": 15 }], 5: [function(require2, module4, exports3) { + "use strict"; + var TYPED_OK = typeof Uint8Array !== "undefined" && typeof Uint16Array !== "undefined" && typeof Int32Array !== "undefined"; + function _has(obj, key) { + return Object.prototype.hasOwnProperty.call(obj, key); + } + exports3.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; + }; + exports3.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); + } + }; + exports3.setTyped = function(on) { + if (on) { + exports3.Buf8 = Uint8Array; + exports3.Buf16 = Uint16Array; + exports3.Buf32 = Int32Array; + exports3.assign(exports3, fnTyped); + } else { + exports3.Buf8 = Array; + exports3.Buf16 = Array; + exports3.Buf32 = Array; + exports3.assign(exports3, fnUntyped); + } + }; + exports3.setTyped(TYPED_OK); + }, {}], 6: [function(require2, module4, exports3) { + "use strict"; + var utils = require2("./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 (var q = 0; q < 256; q++) { + _utf8len[q] = q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1; + } + _utf8len[254] = _utf8len[254] = 1; + exports3.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; + } + exports3.buf2binstring = function(buf) { + return buf2binstring(buf, buf.length); + }; + exports3.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; + }; + exports3.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); + }; + exports3.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; + }; + }, { "./common": 5 }], 7: [function(require2, module4, exports3) { + "use strict"; + 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; + } + module4.exports = adler32; + }, {}], 8: [function(require2, module4, exports3) { + "use strict"; + module4.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 + }; + }, {}], 9: [function(require2, module4, exports3) { + "use strict"; + 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 crc32(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; + } + module4.exports = crc32; + }, {}], 10: [function(require2, module4, exports3) { + "use strict"; + 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; + } + module4.exports = GZheader; + }, {}], 11: [function(require2, module4, exports3) { + "use strict"; + var BAD = 30; + var TYPE = 12; + module4.exports = function inflate_fast(strm, start) { + var state; + var _in; + var last; + 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; + last = _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 < last && _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 < last ? 5 + (last - _in) : 5 - (_in - last); + strm.avail_out = _out < end ? 257 + (end - _out) : 257 - (_out - end); + state.hold = hold; + state.bits = bits; + return; + }; + }, {}], 12: [function(require2, module4, exports3) { + "use strict"; + var utils = require2("../utils/common"); + var adler32 = require2("./adler32"); + var crc32 = require2("./crc32"); + var inflate_fast = require2("./inffast"); + var inflate_table = require2("./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 EXTRA = 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, 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, copy) { + 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 (copy >= 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 > copy) { + dist = copy; + } + utils.arraySet(state.window, src, end - copy, dist, state.wnext); + copy -= dist; + if (copy) { + utils.arraySet(state.window, src, end - copy, copy, 0); + state.wnext = copy; + 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 inflate(strm, flush) { + var state; + var input, output; + var next; + var put; + var have, left; + var hold; + var bits; + var _in, _out; + var copy; + 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 = crc32(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 = crc32(state.check, hbuf, 2, 0); + } + hold = 0; + bits = 0; + state.mode = TIME; + /* falls through */ + 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 = crc32(state.check, hbuf, 4, 0); + } + hold = 0; + bits = 0; + state.mode = OS; + /* falls through */ + 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 = crc32(state.check, hbuf, 2, 0); + } + hold = 0; + bits = 0; + state.mode = EXLEN; + /* falls through */ + 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 = crc32(state.check, hbuf, 2, 0); + } + hold = 0; + bits = 0; + } else if (state.head) { + state.head.extra = null; + } + state.mode = EXTRA; + /* falls through */ + case EXTRA: + if (state.flags & 1024) { + copy = state.length; + if (copy > have) { + copy = have; + } + if (copy) { + 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 + copy, + /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/ + len + ); + } + if (state.flags & 512) { + state.check = crc32(state.check, input, copy, next); + } + have -= copy; + next += copy; + state.length -= copy; + } + if (state.length) { + break inf_leave; + } + } + state.length = 0; + state.mode = NAME; + /* falls through */ + case NAME: + if (state.flags & 2048) { + if (have === 0) { + break inf_leave; + } + copy = 0; + do { + len = input[next + copy++]; + if (state.head && len && state.length < 65536) { + state.head.name += String.fromCharCode(len); + } + } while (len && copy < have); + if (state.flags & 512) { + state.check = crc32(state.check, input, copy, next); + } + have -= copy; + next += copy; + if (len) { + break inf_leave; + } + } else if (state.head) { + state.head.name = null; + } + state.length = 0; + state.mode = COMMENT; + /* falls through */ + case COMMENT: + if (state.flags & 4096) { + if (have === 0) { + break inf_leave; + } + copy = 0; + do { + len = input[next + copy++]; + if (state.head && len && state.length < 65536) { + state.head.comment += String.fromCharCode(len); + } + } while (len && copy < have); + if (state.flags & 512) { + state.check = crc32(state.check, input, copy, next); + } + have -= copy; + next += copy; + if (len) { + break inf_leave; + } + } else if (state.head) { + state.head.comment = null; + } + state.mode = HCRC; + /* falls through */ + 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; + /* falls through */ + 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; + /* falls through */ + case TYPE: + if (flush === Z_BLOCK || flush === Z_TREES) { + break inf_leave; + } + /* falls through */ + 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 (flush === 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 (flush === Z_TREES) { + break inf_leave; + } + /* falls through */ + case COPY_: + state.mode = COPY; + /* falls through */ + case COPY: + copy = state.length; + if (copy) { + if (copy > have) { + copy = have; + } + if (copy > left) { + copy = left; + } + if (copy === 0) { + break inf_leave; + } + utils.arraySet(output, input, next, copy, put); + have -= copy; + next += copy; + left -= copy; + put += copy; + state.length -= copy; + 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; + /* falls through */ + 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; + /* falls through */ + 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]; + copy = 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; + copy = 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; + copy = 11 + (hold & 127); + hold >>>= 7; + bits -= 7; + } + if (state.have + copy > state.nlen + state.ndist) { + strm.msg = "invalid bit length repeat"; + state.mode = BAD; + break; + } + while (copy--) { + 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 (flush === Z_TREES) { + break inf_leave; + } + /* falls through */ + case LEN_: + state.mode = LEN; + /* falls through */ + 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; + /* falls through */ + 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; + /* falls through */ + 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; + /* falls through */ + 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; + /* falls through */ + case MATCH: + if (left === 0) { + break inf_leave; + } + copy = _out - left; + if (state.offset > copy) { + copy = state.offset - copy; + if (copy > state.whave) { + if (state.sane) { + strm.msg = "invalid distance too far back"; + state.mode = BAD; + break; + } + } + if (copy > state.wnext) { + copy -= state.wnext; + from = state.wsize - copy; + } else { + from = state.wnext - copy; + } + if (copy > state.length) { + copy = state.length; + } + from_source = state.window; + } else { + from_source = output; + from = put - state.offset; + copy = state.length; + } + if (copy > left) { + copy = left; + } + left -= copy; + state.length -= copy; + do { + output[put++] = from_source[from++]; + } while (--copy); + 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 ? crc32(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; + /* falls through */ + 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; + /* falls through */ + 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: + /* falls through */ + 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 || flush !== 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 ? crc32(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 || flush === 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; + } + exports3.inflateReset = inflateReset; + exports3.inflateReset2 = inflateReset2; + exports3.inflateResetKeep = inflateResetKeep; + exports3.inflateInit = inflateInit; + exports3.inflateInit2 = inflateInit2; + exports3.inflate = inflate; + exports3.inflateEnd = inflateEnd; + exports3.inflateGetHeader = inflateGetHeader; + exports3.inflateSetDictionary = inflateSetDictionary; + exports3.inflateInfo = "pako inflate (from Nodeca project)"; + }, { "../utils/common": 5, "./adler32": 7, "./crc32": 9, "./inffast": 11, "./inftrees": 13 }], 13: [function(require2, module4, exports3) { + "use strict"; + var utils = require2("../utils/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 + ]; + module4.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 root = 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]]++; + } + root = bits; + for (max = MAXBITS; max >= 1; max--) { + if (count[max] !== 0) { + break; + } + } + if (root > max) { + root = 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 (root < min) { + root = 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 = root; + drop = 0; + low = -1; + used = 1 << root; + 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 > root && (huff & mask) !== low) { + if (drop === 0) { + drop = root; + } + 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] = root << 24 | curr << 16 | next - table_index | 0; + } + } + if (huff !== 0) { + table[next + huff] = len - drop << 24 | 64 << 16 | 0; + } + opts.bits = root; + return 0; + }; + }, { "../utils/common": 5 }], 14: [function(require2, module4, exports3) { + "use strict"; + module4.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) */ + }; + }, {}], 15: [function(require2, module4, exports3) { + "use strict"; + 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; + } + module4.exports = ZStream; + }, {}] }, {}, [3])(3); + }); + } +}); + +// node_modules/plantuml-encoder/browser-index.js +var require_browser_index = __commonJS({ + "node_modules/plantuml-encoder/browser-index.js"(exports, module2) { + module2.exports = { + encode: require_plantuml_encoder().encode, + decode: require_plantuml_decoder().decode + }; + } +}); + +// node_modules/localforage/dist/localforage.js +var require_localforage = __commonJS({ + "node_modules/localforage/dist/localforage.js"(exports, module2) { + (function(f) { + if (typeof exports === "object" && typeof module2 !== "undefined") { + module2.exports = f(); + } else if (typeof define === "function" && define.amd) { + define([], f); + } else { + var g; + if (typeof window !== "undefined") { + g = window; + } else if (typeof global !== "undefined") { + g = global; + } else if (typeof self !== "undefined") { + g = self; + } else { + g = this; + } + g.localforage = f(); + } + })(function() { + var define2, module3, exports2; + return (function e(t, n, r) { + function s(o2, u) { + if (!n[o2]) { + if (!t[o2]) { + var a = typeof require == "function" && require; + if (!u && a) return a(o2, true); + if (i) return i(o2, true); + var f = new Error("Cannot find module '" + o2 + "'"); + throw f.code = "MODULE_NOT_FOUND", f; + } + var l = n[o2] = { exports: {} }; + t[o2][0].call(l.exports, function(e2) { + var n2 = t[o2][1][e2]; + return s(n2 ? n2 : e2); + }, l, l.exports, e, t, n, r); + } + return n[o2].exports; + } + var i = typeof require == "function" && require; + for (var o = 0; o < r.length; o++) s(r[o]); + return s; + })({ 1: [function(_dereq_, module4, exports3) { + (function(global2) { + "use strict"; + var Mutation = global2.MutationObserver || global2.WebKitMutationObserver; + var scheduleDrain; + { + if (Mutation) { + var called = 0; + var observer = new Mutation(nextTick); + var element = global2.document.createTextNode(""); + observer.observe(element, { + characterData: true + }); + scheduleDrain = function() { + element.data = called = ++called % 2; + }; + } else if (!global2.setImmediate && typeof global2.MessageChannel !== "undefined") { + var channel = new global2.MessageChannel(); + channel.port1.onmessage = nextTick; + scheduleDrain = function() { + channel.port2.postMessage(0); + }; + } else if ("document" in global2 && "onreadystatechange" in global2.document.createElement("script")) { + scheduleDrain = function() { + var scriptEl = global2.document.createElement("script"); + scriptEl.onreadystatechange = function() { + nextTick(); + scriptEl.onreadystatechange = null; + scriptEl.parentNode.removeChild(scriptEl); + scriptEl = null; + }; + global2.document.documentElement.appendChild(scriptEl); + }; + } else { + scheduleDrain = function() { + setTimeout(nextTick, 0); + }; + } + } + var draining; + var queue = []; + function nextTick() { + draining = true; + var i, oldQueue; + var len = queue.length; + while (len) { + oldQueue = queue; + queue = []; + i = -1; + while (++i < len) { + oldQueue[i](); + } + len = queue.length; + } + draining = false; + } + module4.exports = immediate; + function immediate(task) { + if (queue.push(task) === 1 && !draining) { + scheduleDrain(); + } + } + }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}); + }, {}], 2: [function(_dereq_, module4, exports3) { + "use strict"; + var immediate = _dereq_(1); + function INTERNAL() { + } + var handlers = {}; + var REJECTED = ["REJECTED"]; + var FULFILLED = ["FULFILLED"]; + var PENDING = ["PENDING"]; + module4.exports = Promise2; + function Promise2(resolver) { + if (typeof resolver !== "function") { + throw new TypeError("resolver must be a function"); + } + this.state = PENDING; + this.queue = []; + this.outcome = void 0; + if (resolver !== INTERNAL) { + safelyResolveThenable(this, resolver); + } + } + Promise2.prototype["catch"] = function(onRejected) { + return this.then(null, onRejected); + }; + Promise2.prototype.then = function(onFulfilled, onRejected) { + if (typeof onFulfilled !== "function" && this.state === FULFILLED || typeof onRejected !== "function" && this.state === REJECTED) { + return this; + } + var promise = new this.constructor(INTERNAL); + if (this.state !== PENDING) { + var resolver = this.state === FULFILLED ? onFulfilled : onRejected; + unwrap(promise, resolver, this.outcome); + } else { + this.queue.push(new QueueItem(promise, onFulfilled, onRejected)); + } + return promise; + }; + function QueueItem(promise, onFulfilled, onRejected) { + this.promise = promise; + if (typeof onFulfilled === "function") { + this.onFulfilled = onFulfilled; + this.callFulfilled = this.otherCallFulfilled; + } + if (typeof onRejected === "function") { + this.onRejected = onRejected; + this.callRejected = this.otherCallRejected; + } + } + QueueItem.prototype.callFulfilled = function(value) { + handlers.resolve(this.promise, value); + }; + QueueItem.prototype.otherCallFulfilled = function(value) { + unwrap(this.promise, this.onFulfilled, value); + }; + QueueItem.prototype.callRejected = function(value) { + handlers.reject(this.promise, value); + }; + QueueItem.prototype.otherCallRejected = function(value) { + unwrap(this.promise, this.onRejected, value); + }; + function unwrap(promise, func, value) { + immediate(function() { + var returnValue; + try { + returnValue = func(value); + } catch (e) { + return handlers.reject(promise, e); + } + if (returnValue === promise) { + handlers.reject(promise, new TypeError("Cannot resolve promise with itself")); + } else { + handlers.resolve(promise, returnValue); + } + }); + } + handlers.resolve = function(self2, value) { + var result = tryCatch(getThen, value); + if (result.status === "error") { + return handlers.reject(self2, result.value); + } + var thenable = result.value; + if (thenable) { + safelyResolveThenable(self2, thenable); + } else { + self2.state = FULFILLED; + self2.outcome = value; + var i = -1; + var len = self2.queue.length; + while (++i < len) { + self2.queue[i].callFulfilled(value); + } + } + return self2; + }; + handlers.reject = function(self2, error) { + self2.state = REJECTED; + self2.outcome = error; + var i = -1; + var len = self2.queue.length; + while (++i < len) { + self2.queue[i].callRejected(error); + } + return self2; + }; + function getThen(obj) { + var then = obj && obj.then; + if (obj && (typeof obj === "object" || typeof obj === "function") && typeof then === "function") { + return function appyThen() { + then.apply(obj, arguments); + }; + } + } + function safelyResolveThenable(self2, thenable) { + var called = false; + function onError(value) { + if (called) { + return; + } + called = true; + handlers.reject(self2, value); + } + function onSuccess(value) { + if (called) { + return; + } + called = true; + handlers.resolve(self2, value); + } + function tryToUnwrap() { + thenable(onSuccess, onError); + } + var result = tryCatch(tryToUnwrap); + if (result.status === "error") { + onError(result.value); + } + } + function tryCatch(func, value) { + var out = {}; + try { + out.value = func(value); + out.status = "success"; + } catch (e) { + out.status = "error"; + out.value = e; + } + return out; + } + Promise2.resolve = resolve; + function resolve(value) { + if (value instanceof this) { + return value; + } + return handlers.resolve(new this(INTERNAL), value); + } + Promise2.reject = reject; + function reject(reason) { + var promise = new this(INTERNAL); + return handlers.reject(promise, reason); + } + Promise2.all = all; + function all(iterable) { + var self2 = this; + if (Object.prototype.toString.call(iterable) !== "[object Array]") { + return this.reject(new TypeError("must be an array")); + } + var len = iterable.length; + var called = false; + if (!len) { + return this.resolve([]); + } + var values = new Array(len); + var resolved = 0; + var i = -1; + var promise = new this(INTERNAL); + while (++i < len) { + allResolver(iterable[i], i); + } + return promise; + function allResolver(value, i2) { + self2.resolve(value).then(resolveFromAll, function(error) { + if (!called) { + called = true; + handlers.reject(promise, error); + } + }); + function resolveFromAll(outValue) { + values[i2] = outValue; + if (++resolved === len && !called) { + called = true; + handlers.resolve(promise, values); + } + } + } + } + Promise2.race = race; + function race(iterable) { + var self2 = this; + if (Object.prototype.toString.call(iterable) !== "[object Array]") { + return this.reject(new TypeError("must be an array")); + } + var len = iterable.length; + var called = false; + if (!len) { + return this.resolve([]); + } + var i = -1; + var promise = new this(INTERNAL); + while (++i < len) { + resolver(iterable[i]); + } + return promise; + function resolver(value) { + self2.resolve(value).then(function(response) { + if (!called) { + called = true; + handlers.resolve(promise, response); + } + }, function(error) { + if (!called) { + called = true; + handlers.reject(promise, error); + } + }); + } + } + }, { "1": 1 }], 3: [function(_dereq_, module4, exports3) { + (function(global2) { + "use strict"; + if (typeof global2.Promise !== "function") { + global2.Promise = _dereq_(2); + } + }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}); + }, { "2": 2 }], 4: [function(_dereq_, module4, exports3) { + "use strict"; + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) { + return typeof obj; + } : function(obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + function getIDB() { + try { + if (typeof indexedDB !== "undefined") { + return indexedDB; + } + if (typeof webkitIndexedDB !== "undefined") { + return webkitIndexedDB; + } + if (typeof mozIndexedDB !== "undefined") { + return mozIndexedDB; + } + if (typeof OIndexedDB !== "undefined") { + return OIndexedDB; + } + if (typeof msIndexedDB !== "undefined") { + return msIndexedDB; + } + } catch (e) { + return; + } + } + var idb = getIDB(); + function isIndexedDBValid() { + try { + if (!idb || !idb.open) { + return false; + } + var isSafari = typeof openDatabase !== "undefined" && /(Safari|iPhone|iPad|iPod)/.test(navigator.userAgent) && !/Chrome/.test(navigator.userAgent) && !/BlackBerry/.test(navigator.platform); + var hasFetch = typeof fetch === "function" && fetch.toString().indexOf("[native code") !== -1; + return (!isSafari || hasFetch) && typeof indexedDB !== "undefined" && // some outdated implementations of IDB that appear on Samsung + // and HTC Android devices <4.4 are missing IDBKeyRange + // See: https://github.com/mozilla/localForage/issues/128 + // See: https://github.com/mozilla/localForage/issues/272 + typeof IDBKeyRange !== "undefined"; + } catch (e) { + return false; + } + } + function createBlob(parts, properties) { + parts = parts || []; + properties = properties || {}; + try { + return new Blob(parts, properties); + } catch (e) { + if (e.name !== "TypeError") { + throw e; + } + var Builder = typeof BlobBuilder !== "undefined" ? BlobBuilder : typeof MSBlobBuilder !== "undefined" ? MSBlobBuilder : typeof MozBlobBuilder !== "undefined" ? MozBlobBuilder : WebKitBlobBuilder; + var builder = new Builder(); + for (var i = 0; i < parts.length; i += 1) { + builder.append(parts[i]); + } + return builder.getBlob(properties.type); + } + } + if (typeof Promise === "undefined") { + _dereq_(3); + } + var Promise$1 = Promise; + function executeCallback(promise, callback) { + if (callback) { + promise.then(function(result) { + callback(null, result); + }, function(error) { + callback(error); + }); + } + } + function executeTwoCallbacks(promise, callback, errorCallback) { + if (typeof callback === "function") { + promise.then(callback); + } + if (typeof errorCallback === "function") { + promise["catch"](errorCallback); + } + } + function normalizeKey(key2) { + if (typeof key2 !== "string") { + console.warn(key2 + " used as a key, but it is not a string."); + key2 = String(key2); + } + return key2; + } + function getCallback() { + if (arguments.length && typeof arguments[arguments.length - 1] === "function") { + return arguments[arguments.length - 1]; + } + } + var DETECT_BLOB_SUPPORT_STORE = "local-forage-detect-blob-support"; + var supportsBlobs = void 0; + var dbContexts = {}; + var toString = Object.prototype.toString; + var READ_ONLY = "readonly"; + var READ_WRITE = "readwrite"; + function _binStringToArrayBuffer(bin) { + var length2 = bin.length; + var buf = new ArrayBuffer(length2); + var arr = new Uint8Array(buf); + for (var i = 0; i < length2; i++) { + arr[i] = bin.charCodeAt(i); + } + return buf; + } + function _checkBlobSupportWithoutCaching(idb2) { + return new Promise$1(function(resolve) { + var txn = idb2.transaction(DETECT_BLOB_SUPPORT_STORE, READ_WRITE); + var blob = createBlob([""]); + txn.objectStore(DETECT_BLOB_SUPPORT_STORE).put(blob, "key"); + txn.onabort = function(e) { + e.preventDefault(); + e.stopPropagation(); + resolve(false); + }; + txn.oncomplete = function() { + var matchedChrome = navigator.userAgent.match(/Chrome\/(\d+)/); + var matchedEdge = navigator.userAgent.match(/Edge\//); + resolve(matchedEdge || !matchedChrome || parseInt(matchedChrome[1], 10) >= 43); + }; + })["catch"](function() { + return false; + }); + } + function _checkBlobSupport(idb2) { + if (typeof supportsBlobs === "boolean") { + return Promise$1.resolve(supportsBlobs); + } + return _checkBlobSupportWithoutCaching(idb2).then(function(value) { + supportsBlobs = value; + return supportsBlobs; + }); + } + function _deferReadiness(dbInfo) { + var dbContext = dbContexts[dbInfo.name]; + var deferredOperation = {}; + deferredOperation.promise = new Promise$1(function(resolve, reject) { + deferredOperation.resolve = resolve; + deferredOperation.reject = reject; + }); + dbContext.deferredOperations.push(deferredOperation); + if (!dbContext.dbReady) { + dbContext.dbReady = deferredOperation.promise; + } else { + dbContext.dbReady = dbContext.dbReady.then(function() { + return deferredOperation.promise; + }); + } + } + function _advanceReadiness(dbInfo) { + var dbContext = dbContexts[dbInfo.name]; + var deferredOperation = dbContext.deferredOperations.pop(); + if (deferredOperation) { + deferredOperation.resolve(); + return deferredOperation.promise; + } + } + function _rejectReadiness(dbInfo, err) { + var dbContext = dbContexts[dbInfo.name]; + var deferredOperation = dbContext.deferredOperations.pop(); + if (deferredOperation) { + deferredOperation.reject(err); + return deferredOperation.promise; + } + } + function _getConnection(dbInfo, upgradeNeeded) { + return new Promise$1(function(resolve, reject) { + dbContexts[dbInfo.name] = dbContexts[dbInfo.name] || createDbContext(); + if (dbInfo.db) { + if (upgradeNeeded) { + _deferReadiness(dbInfo); + dbInfo.db.close(); + } else { + return resolve(dbInfo.db); + } + } + var dbArgs = [dbInfo.name]; + if (upgradeNeeded) { + dbArgs.push(dbInfo.version); + } + var openreq = idb.open.apply(idb, dbArgs); + if (upgradeNeeded) { + openreq.onupgradeneeded = function(e) { + var db = openreq.result; + try { + db.createObjectStore(dbInfo.storeName); + if (e.oldVersion <= 1) { + db.createObjectStore(DETECT_BLOB_SUPPORT_STORE); + } + } catch (ex) { + if (ex.name === "ConstraintError") { + console.warn('The database "' + dbInfo.name + '" has been upgraded from version ' + e.oldVersion + " to version " + e.newVersion + ', but the storage "' + dbInfo.storeName + '" already exists.'); + } else { + throw ex; + } + } + }; + } + openreq.onerror = function(e) { + e.preventDefault(); + reject(openreq.error); + }; + openreq.onsuccess = function() { + var db = openreq.result; + db.onversionchange = function(e) { + e.target.close(); + }; + resolve(db); + _advanceReadiness(dbInfo); + }; + }); + } + function _getOriginalConnection(dbInfo) { + return _getConnection(dbInfo, false); + } + function _getUpgradedConnection(dbInfo) { + return _getConnection(dbInfo, true); + } + function _isUpgradeNeeded(dbInfo, defaultVersion) { + if (!dbInfo.db) { + return true; + } + var isNewStore = !dbInfo.db.objectStoreNames.contains(dbInfo.storeName); + var isDowngrade = dbInfo.version < dbInfo.db.version; + var isUpgrade = dbInfo.version > dbInfo.db.version; + if (isDowngrade) { + if (dbInfo.version !== defaultVersion) { + console.warn('The database "' + dbInfo.name + `" can't be downgraded from version ` + dbInfo.db.version + " to version " + dbInfo.version + "."); + } + dbInfo.version = dbInfo.db.version; + } + if (isUpgrade || isNewStore) { + if (isNewStore) { + var incVersion = dbInfo.db.version + 1; + if (incVersion > dbInfo.version) { + dbInfo.version = incVersion; + } + } + return true; + } + return false; + } + function _encodeBlob(blob) { + return new Promise$1(function(resolve, reject) { + var reader = new FileReader(); + reader.onerror = reject; + reader.onloadend = function(e) { + var base64 = btoa(e.target.result || ""); + resolve({ + __local_forage_encoded_blob: true, + data: base64, + type: blob.type + }); + }; + reader.readAsBinaryString(blob); + }); + } + function _decodeBlob(encodedBlob) { + var arrayBuff = _binStringToArrayBuffer(atob(encodedBlob.data)); + return createBlob([arrayBuff], { type: encodedBlob.type }); + } + function _isEncodedBlob(value) { + return value && value.__local_forage_encoded_blob; + } + function _fullyReady(callback) { + var self2 = this; + var promise = self2._initReady().then(function() { + var dbContext = dbContexts[self2._dbInfo.name]; + if (dbContext && dbContext.dbReady) { + return dbContext.dbReady; + } + }); + executeTwoCallbacks(promise, callback, callback); + return promise; + } + function _tryReconnect(dbInfo) { + _deferReadiness(dbInfo); + var dbContext = dbContexts[dbInfo.name]; + var forages = dbContext.forages; + for (var i = 0; i < forages.length; i++) { + var forage = forages[i]; + if (forage._dbInfo.db) { + forage._dbInfo.db.close(); + forage._dbInfo.db = null; + } + } + dbInfo.db = null; + return _getOriginalConnection(dbInfo).then(function(db) { + dbInfo.db = db; + if (_isUpgradeNeeded(dbInfo)) { + return _getUpgradedConnection(dbInfo); + } + return db; + }).then(function(db) { + dbInfo.db = dbContext.db = db; + for (var i2 = 0; i2 < forages.length; i2++) { + forages[i2]._dbInfo.db = db; + } + })["catch"](function(err) { + _rejectReadiness(dbInfo, err); + throw err; + }); + } + function createTransaction(dbInfo, mode, callback, retries) { + if (retries === void 0) { + retries = 1; + } + try { + var tx = dbInfo.db.transaction(dbInfo.storeName, mode); + callback(null, tx); + } catch (err) { + if (retries > 0 && (!dbInfo.db || err.name === "InvalidStateError" || err.name === "NotFoundError")) { + return Promise$1.resolve().then(function() { + if (!dbInfo.db || err.name === "NotFoundError" && !dbInfo.db.objectStoreNames.contains(dbInfo.storeName) && dbInfo.version <= dbInfo.db.version) { + if (dbInfo.db) { + dbInfo.version = dbInfo.db.version + 1; + } + return _getUpgradedConnection(dbInfo); + } + }).then(function() { + return _tryReconnect(dbInfo).then(function() { + createTransaction(dbInfo, mode, callback, retries - 1); + }); + })["catch"](callback); + } + callback(err); + } + } + function createDbContext() { + return { + // Running localForages sharing a database. + forages: [], + // Shared database. + db: null, + // Database readiness (promise). + dbReady: null, + // Deferred operations on the database. + deferredOperations: [] + }; + } + function _initStorage(options) { + var self2 = this; + var dbInfo = { + db: null + }; + if (options) { + for (var i in options) { + dbInfo[i] = options[i]; + } + } + var dbContext = dbContexts[dbInfo.name]; + if (!dbContext) { + dbContext = createDbContext(); + dbContexts[dbInfo.name] = dbContext; + } + dbContext.forages.push(self2); + if (!self2._initReady) { + self2._initReady = self2.ready; + self2.ready = _fullyReady; + } + var initPromises = []; + function ignoreErrors() { + return Promise$1.resolve(); + } + for (var j = 0; j < dbContext.forages.length; j++) { + var forage = dbContext.forages[j]; + if (forage !== self2) { + initPromises.push(forage._initReady()["catch"](ignoreErrors)); + } + } + var forages = dbContext.forages.slice(0); + return Promise$1.all(initPromises).then(function() { + dbInfo.db = dbContext.db; + return _getOriginalConnection(dbInfo); + }).then(function(db) { + dbInfo.db = db; + if (_isUpgradeNeeded(dbInfo, self2._defaultConfig.version)) { + return _getUpgradedConnection(dbInfo); + } + return db; + }).then(function(db) { + dbInfo.db = dbContext.db = db; + self2._dbInfo = dbInfo; + for (var k = 0; k < forages.length; k++) { + var forage2 = forages[k]; + if (forage2 !== self2) { + forage2._dbInfo.db = dbInfo.db; + forage2._dbInfo.version = dbInfo.version; + } + } + }); + } + function getItem2(key2, callback) { + var self2 = this; + key2 = normalizeKey(key2); + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + createTransaction(self2._dbInfo, READ_ONLY, function(err, transaction) { + if (err) { + return reject(err); + } + try { + var store = transaction.objectStore(self2._dbInfo.storeName); + var req = store.get(key2); + req.onsuccess = function() { + var value = req.result; + if (value === void 0) { + value = null; + } + if (_isEncodedBlob(value)) { + value = _decodeBlob(value); + } + resolve(value); + }; + req.onerror = function() { + reject(req.error); + }; + } catch (e) { + reject(e); + } + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function iterate(iterator, callback) { + var self2 = this; + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + createTransaction(self2._dbInfo, READ_ONLY, function(err, transaction) { + if (err) { + return reject(err); + } + try { + var store = transaction.objectStore(self2._dbInfo.storeName); + var req = store.openCursor(); + var iterationNumber = 1; + req.onsuccess = function() { + var cursor = req.result; + if (cursor) { + var value = cursor.value; + if (_isEncodedBlob(value)) { + value = _decodeBlob(value); + } + var result = iterator(value, cursor.key, iterationNumber++); + if (result !== void 0) { + resolve(result); + } else { + cursor["continue"](); + } + } else { + resolve(); + } + }; + req.onerror = function() { + reject(req.error); + }; + } catch (e) { + reject(e); + } + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function setItem2(key2, value, callback) { + var self2 = this; + key2 = normalizeKey(key2); + var promise = new Promise$1(function(resolve, reject) { + var dbInfo; + self2.ready().then(function() { + dbInfo = self2._dbInfo; + if (toString.call(value) === "[object Blob]") { + return _checkBlobSupport(dbInfo.db).then(function(blobSupport) { + if (blobSupport) { + return value; + } + return _encodeBlob(value); + }); + } + return value; + }).then(function(value2) { + createTransaction(self2._dbInfo, READ_WRITE, function(err, transaction) { + if (err) { + return reject(err); + } + try { + var store = transaction.objectStore(self2._dbInfo.storeName); + if (value2 === null) { + value2 = void 0; + } + var req = store.put(value2, key2); + transaction.oncomplete = function() { + if (value2 === void 0) { + value2 = null; + } + resolve(value2); + }; + transaction.onabort = transaction.onerror = function() { + var err2 = req.error ? req.error : req.transaction.error; + reject(err2); + }; + } catch (e) { + reject(e); + } + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function removeItem(key2, callback) { + var self2 = this; + key2 = normalizeKey(key2); + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + createTransaction(self2._dbInfo, READ_WRITE, function(err, transaction) { + if (err) { + return reject(err); + } + try { + var store = transaction.objectStore(self2._dbInfo.storeName); + var req = store["delete"](key2); + transaction.oncomplete = function() { + resolve(); + }; + transaction.onerror = function() { + reject(req.error); + }; + transaction.onabort = function() { + var err2 = req.error ? req.error : req.transaction.error; + reject(err2); + }; + } catch (e) { + reject(e); + } + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function clear(callback) { + var self2 = this; + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + createTransaction(self2._dbInfo, READ_WRITE, function(err, transaction) { + if (err) { + return reject(err); + } + try { + var store = transaction.objectStore(self2._dbInfo.storeName); + var req = store.clear(); + transaction.oncomplete = function() { + resolve(); + }; + transaction.onabort = transaction.onerror = function() { + var err2 = req.error ? req.error : req.transaction.error; + reject(err2); + }; + } catch (e) { + reject(e); + } + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function length(callback) { + var self2 = this; + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + createTransaction(self2._dbInfo, READ_ONLY, function(err, transaction) { + if (err) { + return reject(err); + } + try { + var store = transaction.objectStore(self2._dbInfo.storeName); + var req = store.count(); + req.onsuccess = function() { + resolve(req.result); + }; + req.onerror = function() { + reject(req.error); + }; + } catch (e) { + reject(e); + } + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function key(n, callback) { + var self2 = this; + var promise = new Promise$1(function(resolve, reject) { + if (n < 0) { + resolve(null); + return; + } + self2.ready().then(function() { + createTransaction(self2._dbInfo, READ_ONLY, function(err, transaction) { + if (err) { + return reject(err); + } + try { + var store = transaction.objectStore(self2._dbInfo.storeName); + var advanced = false; + var req = store.openKeyCursor(); + req.onsuccess = function() { + var cursor = req.result; + if (!cursor) { + resolve(null); + return; + } + if (n === 0) { + resolve(cursor.key); + } else { + if (!advanced) { + advanced = true; + cursor.advance(n); + } else { + resolve(cursor.key); + } + } + }; + req.onerror = function() { + reject(req.error); + }; + } catch (e) { + reject(e); + } + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function keys(callback) { + var self2 = this; + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + createTransaction(self2._dbInfo, READ_ONLY, function(err, transaction) { + if (err) { + return reject(err); + } + try { + var store = transaction.objectStore(self2._dbInfo.storeName); + var req = store.openKeyCursor(); + var keys2 = []; + req.onsuccess = function() { + var cursor = req.result; + if (!cursor) { + resolve(keys2); + return; + } + keys2.push(cursor.key); + cursor["continue"](); + }; + req.onerror = function() { + reject(req.error); + }; + } catch (e) { + reject(e); + } + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function dropInstance(options, callback) { + callback = getCallback.apply(this, arguments); + var currentConfig = this.config(); + options = typeof options !== "function" && options || {}; + if (!options.name) { + options.name = options.name || currentConfig.name; + options.storeName = options.storeName || currentConfig.storeName; + } + var self2 = this; + var promise; + if (!options.name) { + promise = Promise$1.reject("Invalid arguments"); + } else { + var isCurrentDb = options.name === currentConfig.name && self2._dbInfo.db; + var dbPromise = isCurrentDb ? Promise$1.resolve(self2._dbInfo.db) : _getOriginalConnection(options).then(function(db) { + var dbContext = dbContexts[options.name]; + var forages = dbContext.forages; + dbContext.db = db; + for (var i = 0; i < forages.length; i++) { + forages[i]._dbInfo.db = db; + } + return db; + }); + if (!options.storeName) { + promise = dbPromise.then(function(db) { + _deferReadiness(options); + var dbContext = dbContexts[options.name]; + var forages = dbContext.forages; + db.close(); + for (var i = 0; i < forages.length; i++) { + var forage = forages[i]; + forage._dbInfo.db = null; + } + var dropDBPromise = new Promise$1(function(resolve, reject) { + var req = idb.deleteDatabase(options.name); + req.onerror = function() { + var db2 = req.result; + if (db2) { + db2.close(); + } + reject(req.error); + }; + req.onblocked = function() { + console.warn('dropInstance blocked for database "' + options.name + '" until all open connections are closed'); + }; + req.onsuccess = function() { + var db2 = req.result; + if (db2) { + db2.close(); + } + resolve(db2); + }; + }); + return dropDBPromise.then(function(db2) { + dbContext.db = db2; + for (var i2 = 0; i2 < forages.length; i2++) { + var _forage = forages[i2]; + _advanceReadiness(_forage._dbInfo); + } + })["catch"](function(err) { + (_rejectReadiness(options, err) || Promise$1.resolve())["catch"](function() { + }); + throw err; + }); + }); + } else { + promise = dbPromise.then(function(db) { + if (!db.objectStoreNames.contains(options.storeName)) { + return; + } + var newVersion = db.version + 1; + _deferReadiness(options); + var dbContext = dbContexts[options.name]; + var forages = dbContext.forages; + db.close(); + for (var i = 0; i < forages.length; i++) { + var forage = forages[i]; + forage._dbInfo.db = null; + forage._dbInfo.version = newVersion; + } + var dropObjectPromise = new Promise$1(function(resolve, reject) { + var req = idb.open(options.name, newVersion); + req.onerror = function(err) { + var db2 = req.result; + db2.close(); + reject(err); + }; + req.onupgradeneeded = function() { + var db2 = req.result; + db2.deleteObjectStore(options.storeName); + }; + req.onsuccess = function() { + var db2 = req.result; + db2.close(); + resolve(db2); + }; + }); + return dropObjectPromise.then(function(db2) { + dbContext.db = db2; + for (var j = 0; j < forages.length; j++) { + var _forage2 = forages[j]; + _forage2._dbInfo.db = db2; + _advanceReadiness(_forage2._dbInfo); + } + })["catch"](function(err) { + (_rejectReadiness(options, err) || Promise$1.resolve())["catch"](function() { + }); + throw err; + }); + }); + } + } + executeCallback(promise, callback); + return promise; + } + var asyncStorage = { + _driver: "asyncStorage", + _initStorage, + _support: isIndexedDBValid(), + iterate, + getItem: getItem2, + setItem: setItem2, + removeItem, + clear, + length, + key, + keys, + dropInstance + }; + function isWebSQLValid() { + return typeof openDatabase === "function"; + } + var BASE_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + var BLOB_TYPE_PREFIX = "~~local_forage_type~"; + var BLOB_TYPE_PREFIX_REGEX = /^~~local_forage_type~([^~]+)~/; + var SERIALIZED_MARKER = "__lfsc__:"; + var SERIALIZED_MARKER_LENGTH = SERIALIZED_MARKER.length; + var TYPE_ARRAYBUFFER = "arbf"; + var TYPE_BLOB = "blob"; + var TYPE_INT8ARRAY = "si08"; + var TYPE_UINT8ARRAY = "ui08"; + var TYPE_UINT8CLAMPEDARRAY = "uic8"; + var TYPE_INT16ARRAY = "si16"; + var TYPE_INT32ARRAY = "si32"; + var TYPE_UINT16ARRAY = "ur16"; + var TYPE_UINT32ARRAY = "ui32"; + var TYPE_FLOAT32ARRAY = "fl32"; + var TYPE_FLOAT64ARRAY = "fl64"; + var TYPE_SERIALIZED_MARKER_LENGTH = SERIALIZED_MARKER_LENGTH + TYPE_ARRAYBUFFER.length; + var toString$1 = Object.prototype.toString; + function stringToBuffer(serializedString) { + var bufferLength = serializedString.length * 0.75; + var len = serializedString.length; + var i; + var p = 0; + var encoded1, encoded2, encoded3, encoded4; + if (serializedString[serializedString.length - 1] === "=") { + bufferLength--; + if (serializedString[serializedString.length - 2] === "=") { + bufferLength--; + } + } + var buffer = new ArrayBuffer(bufferLength); + var bytes = new Uint8Array(buffer); + for (i = 0; i < len; i += 4) { + encoded1 = BASE_CHARS.indexOf(serializedString[i]); + encoded2 = BASE_CHARS.indexOf(serializedString[i + 1]); + encoded3 = BASE_CHARS.indexOf(serializedString[i + 2]); + encoded4 = BASE_CHARS.indexOf(serializedString[i + 3]); + bytes[p++] = encoded1 << 2 | encoded2 >> 4; + bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2; + bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63; + } + return buffer; + } + function bufferToString(buffer) { + var bytes = new Uint8Array(buffer); + var base64String = ""; + var i; + for (i = 0; i < bytes.length; i += 3) { + base64String += BASE_CHARS[bytes[i] >> 2]; + base64String += BASE_CHARS[(bytes[i] & 3) << 4 | bytes[i + 1] >> 4]; + base64String += BASE_CHARS[(bytes[i + 1] & 15) << 2 | bytes[i + 2] >> 6]; + base64String += BASE_CHARS[bytes[i + 2] & 63]; + } + if (bytes.length % 3 === 2) { + base64String = base64String.substring(0, base64String.length - 1) + "="; + } else if (bytes.length % 3 === 1) { + base64String = base64String.substring(0, base64String.length - 2) + "=="; + } + return base64String; + } + function serialize(value, callback) { + var valueType = ""; + if (value) { + valueType = toString$1.call(value); + } + if (value && (valueType === "[object ArrayBuffer]" || value.buffer && toString$1.call(value.buffer) === "[object ArrayBuffer]")) { + var buffer; + var marker = SERIALIZED_MARKER; + if (value instanceof ArrayBuffer) { + buffer = value; + marker += TYPE_ARRAYBUFFER; + } else { + buffer = value.buffer; + if (valueType === "[object Int8Array]") { + marker += TYPE_INT8ARRAY; + } else if (valueType === "[object Uint8Array]") { + marker += TYPE_UINT8ARRAY; + } else if (valueType === "[object Uint8ClampedArray]") { + marker += TYPE_UINT8CLAMPEDARRAY; + } else if (valueType === "[object Int16Array]") { + marker += TYPE_INT16ARRAY; + } else if (valueType === "[object Uint16Array]") { + marker += TYPE_UINT16ARRAY; + } else if (valueType === "[object Int32Array]") { + marker += TYPE_INT32ARRAY; + } else if (valueType === "[object Uint32Array]") { + marker += TYPE_UINT32ARRAY; + } else if (valueType === "[object Float32Array]") { + marker += TYPE_FLOAT32ARRAY; + } else if (valueType === "[object Float64Array]") { + marker += TYPE_FLOAT64ARRAY; + } else { + callback(new Error("Failed to get type for BinaryArray")); + } + } + callback(marker + bufferToString(buffer)); + } else if (valueType === "[object Blob]") { + var fileReader = new FileReader(); + fileReader.onload = function() { + var str = BLOB_TYPE_PREFIX + value.type + "~" + bufferToString(this.result); + callback(SERIALIZED_MARKER + TYPE_BLOB + str); + }; + fileReader.readAsArrayBuffer(value); + } else { + try { + callback(JSON.stringify(value)); + } catch (e) { + console.error("Couldn't convert value into a JSON string: ", value); + callback(null, e); + } + } + } + function deserialize(value) { + if (value.substring(0, SERIALIZED_MARKER_LENGTH) !== SERIALIZED_MARKER) { + return JSON.parse(value); + } + var serializedString = value.substring(TYPE_SERIALIZED_MARKER_LENGTH); + var type = value.substring(SERIALIZED_MARKER_LENGTH, TYPE_SERIALIZED_MARKER_LENGTH); + var blobType; + if (type === TYPE_BLOB && BLOB_TYPE_PREFIX_REGEX.test(serializedString)) { + var matcher = serializedString.match(BLOB_TYPE_PREFIX_REGEX); + blobType = matcher[1]; + serializedString = serializedString.substring(matcher[0].length); + } + var buffer = stringToBuffer(serializedString); + switch (type) { + case TYPE_ARRAYBUFFER: + return buffer; + case TYPE_BLOB: + return createBlob([buffer], { type: blobType }); + case TYPE_INT8ARRAY: + return new Int8Array(buffer); + case TYPE_UINT8ARRAY: + return new Uint8Array(buffer); + case TYPE_UINT8CLAMPEDARRAY: + return new Uint8ClampedArray(buffer); + case TYPE_INT16ARRAY: + return new Int16Array(buffer); + case TYPE_UINT16ARRAY: + return new Uint16Array(buffer); + case TYPE_INT32ARRAY: + return new Int32Array(buffer); + case TYPE_UINT32ARRAY: + return new Uint32Array(buffer); + case TYPE_FLOAT32ARRAY: + return new Float32Array(buffer); + case TYPE_FLOAT64ARRAY: + return new Float64Array(buffer); + default: + throw new Error("Unkown type: " + type); + } + } + var localforageSerializer = { + serialize, + deserialize, + stringToBuffer, + bufferToString + }; + function createDbTable(t, dbInfo, callback, errorCallback) { + t.executeSql("CREATE TABLE IF NOT EXISTS " + dbInfo.storeName + " (id INTEGER PRIMARY KEY, key unique, value)", [], callback, errorCallback); + } + function _initStorage$1(options) { + var self2 = this; + var dbInfo = { + db: null + }; + if (options) { + for (var i in options) { + dbInfo[i] = typeof options[i] !== "string" ? options[i].toString() : options[i]; + } + } + var dbInfoPromise = new Promise$1(function(resolve, reject) { + try { + dbInfo.db = openDatabase(dbInfo.name, String(dbInfo.version), dbInfo.description, dbInfo.size); + } catch (e) { + return reject(e); + } + dbInfo.db.transaction(function(t) { + createDbTable(t, dbInfo, function() { + self2._dbInfo = dbInfo; + resolve(); + }, function(t2, error) { + reject(error); + }); + }, reject); + }); + dbInfo.serializer = localforageSerializer; + return dbInfoPromise; + } + function tryExecuteSql(t, dbInfo, sqlStatement, args, callback, errorCallback) { + t.executeSql(sqlStatement, args, callback, function(t2, error) { + if (error.code === error.SYNTAX_ERR) { + t2.executeSql("SELECT name FROM sqlite_master WHERE type='table' AND name = ?", [dbInfo.storeName], function(t3, results) { + if (!results.rows.length) { + createDbTable(t3, dbInfo, function() { + t3.executeSql(sqlStatement, args, callback, errorCallback); + }, errorCallback); + } else { + errorCallback(t3, error); + } + }, errorCallback); + } else { + errorCallback(t2, error); + } + }, errorCallback); + } + function getItem$1(key2, callback) { + var self2 = this; + key2 = normalizeKey(key2); + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + var dbInfo = self2._dbInfo; + dbInfo.db.transaction(function(t) { + tryExecuteSql(t, dbInfo, "SELECT * FROM " + dbInfo.storeName + " WHERE key = ? LIMIT 1", [key2], function(t2, results) { + var result = results.rows.length ? results.rows.item(0).value : null; + if (result) { + result = dbInfo.serializer.deserialize(result); + } + resolve(result); + }, function(t2, error) { + reject(error); + }); + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function iterate$1(iterator, callback) { + var self2 = this; + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + var dbInfo = self2._dbInfo; + dbInfo.db.transaction(function(t) { + tryExecuteSql(t, dbInfo, "SELECT * FROM " + dbInfo.storeName, [], function(t2, results) { + var rows = results.rows; + var length2 = rows.length; + for (var i = 0; i < length2; i++) { + var item = rows.item(i); + var result = item.value; + if (result) { + result = dbInfo.serializer.deserialize(result); + } + result = iterator(result, item.key, i + 1); + if (result !== void 0) { + resolve(result); + return; + } + } + resolve(); + }, function(t2, error) { + reject(error); + }); + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function _setItem(key2, value, callback, retriesLeft) { + var self2 = this; + key2 = normalizeKey(key2); + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + if (value === void 0) { + value = null; + } + var originalValue = value; + var dbInfo = self2._dbInfo; + dbInfo.serializer.serialize(value, function(value2, error) { + if (error) { + reject(error); + } else { + dbInfo.db.transaction(function(t) { + tryExecuteSql(t, dbInfo, "INSERT OR REPLACE INTO " + dbInfo.storeName + " (key, value) VALUES (?, ?)", [key2, value2], function() { + resolve(originalValue); + }, function(t2, error2) { + reject(error2); + }); + }, function(sqlError) { + if (sqlError.code === sqlError.QUOTA_ERR) { + if (retriesLeft > 0) { + resolve(_setItem.apply(self2, [key2, originalValue, callback, retriesLeft - 1])); + return; + } + reject(sqlError); + } + }); + } + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function setItem$1(key2, value, callback) { + return _setItem.apply(this, [key2, value, callback, 1]); + } + function removeItem$1(key2, callback) { + var self2 = this; + key2 = normalizeKey(key2); + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + var dbInfo = self2._dbInfo; + dbInfo.db.transaction(function(t) { + tryExecuteSql(t, dbInfo, "DELETE FROM " + dbInfo.storeName + " WHERE key = ?", [key2], function() { + resolve(); + }, function(t2, error) { + reject(error); + }); + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function clear$1(callback) { + var self2 = this; + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + var dbInfo = self2._dbInfo; + dbInfo.db.transaction(function(t) { + tryExecuteSql(t, dbInfo, "DELETE FROM " + dbInfo.storeName, [], function() { + resolve(); + }, function(t2, error) { + reject(error); + }); + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function length$1(callback) { + var self2 = this; + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + var dbInfo = self2._dbInfo; + dbInfo.db.transaction(function(t) { + tryExecuteSql(t, dbInfo, "SELECT COUNT(key) as c FROM " + dbInfo.storeName, [], function(t2, results) { + var result = results.rows.item(0).c; + resolve(result); + }, function(t2, error) { + reject(error); + }); + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function key$1(n, callback) { + var self2 = this; + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + var dbInfo = self2._dbInfo; + dbInfo.db.transaction(function(t) { + tryExecuteSql(t, dbInfo, "SELECT key FROM " + dbInfo.storeName + " WHERE id = ? LIMIT 1", [n + 1], function(t2, results) { + var result = results.rows.length ? results.rows.item(0).key : null; + resolve(result); + }, function(t2, error) { + reject(error); + }); + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function keys$1(callback) { + var self2 = this; + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + var dbInfo = self2._dbInfo; + dbInfo.db.transaction(function(t) { + tryExecuteSql(t, dbInfo, "SELECT key FROM " + dbInfo.storeName, [], function(t2, results) { + var keys2 = []; + for (var i = 0; i < results.rows.length; i++) { + keys2.push(results.rows.item(i).key); + } + resolve(keys2); + }, function(t2, error) { + reject(error); + }); + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function getAllStoreNames(db) { + return new Promise$1(function(resolve, reject) { + db.transaction(function(t) { + t.executeSql("SELECT name FROM sqlite_master WHERE type='table' AND name <> '__WebKitDatabaseInfoTable__'", [], function(t2, results) { + var storeNames = []; + for (var i = 0; i < results.rows.length; i++) { + storeNames.push(results.rows.item(i).name); + } + resolve({ + db, + storeNames + }); + }, function(t2, error) { + reject(error); + }); + }, function(sqlError) { + reject(sqlError); + }); + }); + } + function dropInstance$1(options, callback) { + callback = getCallback.apply(this, arguments); + var currentConfig = this.config(); + options = typeof options !== "function" && options || {}; + if (!options.name) { + options.name = options.name || currentConfig.name; + options.storeName = options.storeName || currentConfig.storeName; + } + var self2 = this; + var promise; + if (!options.name) { + promise = Promise$1.reject("Invalid arguments"); + } else { + promise = new Promise$1(function(resolve) { + var db; + if (options.name === currentConfig.name) { + db = self2._dbInfo.db; + } else { + db = openDatabase(options.name, "", "", 0); + } + if (!options.storeName) { + resolve(getAllStoreNames(db)); + } else { + resolve({ + db, + storeNames: [options.storeName] + }); + } + }).then(function(operationInfo) { + return new Promise$1(function(resolve, reject) { + operationInfo.db.transaction(function(t) { + function dropTable(storeName) { + return new Promise$1(function(resolve2, reject2) { + t.executeSql("DROP TABLE IF EXISTS " + storeName, [], function() { + resolve2(); + }, function(t2, error) { + reject2(error); + }); + }); + } + var operations = []; + for (var i = 0, len = operationInfo.storeNames.length; i < len; i++) { + operations.push(dropTable(operationInfo.storeNames[i])); + } + Promise$1.all(operations).then(function() { + resolve(); + })["catch"](function(e) { + reject(e); + }); + }, function(sqlError) { + reject(sqlError); + }); + }); + }); + } + executeCallback(promise, callback); + return promise; + } + var webSQLStorage = { + _driver: "webSQLStorage", + _initStorage: _initStorage$1, + _support: isWebSQLValid(), + iterate: iterate$1, + getItem: getItem$1, + setItem: setItem$1, + removeItem: removeItem$1, + clear: clear$1, + length: length$1, + key: key$1, + keys: keys$1, + dropInstance: dropInstance$1 + }; + function isLocalStorageValid() { + try { + return typeof localStorage !== "undefined" && "setItem" in localStorage && // in IE8 typeof localStorage.setItem === 'object' + !!localStorage.setItem; + } catch (e) { + return false; + } + } + function _getKeyPrefix(options, defaultConfig) { + var keyPrefix = options.name + "/"; + if (options.storeName !== defaultConfig.storeName) { + keyPrefix += options.storeName + "/"; + } + return keyPrefix; + } + function checkIfLocalStorageThrows() { + var localStorageTestKey = "_localforage_support_test"; + try { + localStorage.setItem(localStorageTestKey, true); + localStorage.removeItem(localStorageTestKey); + return false; + } catch (e) { + return true; + } + } + function _isLocalStorageUsable() { + return !checkIfLocalStorageThrows() || localStorage.length > 0; + } + function _initStorage$2(options) { + var self2 = this; + var dbInfo = {}; + if (options) { + for (var i in options) { + dbInfo[i] = options[i]; + } + } + dbInfo.keyPrefix = _getKeyPrefix(options, self2._defaultConfig); + if (!_isLocalStorageUsable()) { + return Promise$1.reject(); + } + self2._dbInfo = dbInfo; + dbInfo.serializer = localforageSerializer; + return Promise$1.resolve(); + } + function clear$2(callback) { + var self2 = this; + var promise = self2.ready().then(function() { + var keyPrefix = self2._dbInfo.keyPrefix; + for (var i = localStorage.length - 1; i >= 0; i--) { + var key2 = localStorage.key(i); + if (key2.indexOf(keyPrefix) === 0) { + localStorage.removeItem(key2); + } + } + }); + executeCallback(promise, callback); + return promise; + } + function getItem$2(key2, callback) { + var self2 = this; + key2 = normalizeKey(key2); + var promise = self2.ready().then(function() { + var dbInfo = self2._dbInfo; + var result = localStorage.getItem(dbInfo.keyPrefix + key2); + if (result) { + result = dbInfo.serializer.deserialize(result); + } + return result; + }); + executeCallback(promise, callback); + return promise; + } + function iterate$2(iterator, callback) { + var self2 = this; + var promise = self2.ready().then(function() { + var dbInfo = self2._dbInfo; + var keyPrefix = dbInfo.keyPrefix; + var keyPrefixLength = keyPrefix.length; + var length2 = localStorage.length; + var iterationNumber = 1; + for (var i = 0; i < length2; i++) { + var key2 = localStorage.key(i); + if (key2.indexOf(keyPrefix) !== 0) { + continue; + } + var value = localStorage.getItem(key2); + if (value) { + value = dbInfo.serializer.deserialize(value); + } + value = iterator(value, key2.substring(keyPrefixLength), iterationNumber++); + if (value !== void 0) { + return value; + } + } + }); + executeCallback(promise, callback); + return promise; + } + function key$2(n, callback) { + var self2 = this; + var promise = self2.ready().then(function() { + var dbInfo = self2._dbInfo; + var result; + try { + result = localStorage.key(n); + } catch (error) { + result = null; + } + if (result) { + result = result.substring(dbInfo.keyPrefix.length); + } + return result; + }); + executeCallback(promise, callback); + return promise; + } + function keys$2(callback) { + var self2 = this; + var promise = self2.ready().then(function() { + var dbInfo = self2._dbInfo; + var length2 = localStorage.length; + var keys2 = []; + for (var i = 0; i < length2; i++) { + var itemKey = localStorage.key(i); + if (itemKey.indexOf(dbInfo.keyPrefix) === 0) { + keys2.push(itemKey.substring(dbInfo.keyPrefix.length)); + } + } + return keys2; + }); + executeCallback(promise, callback); + return promise; + } + function length$2(callback) { + var self2 = this; + var promise = self2.keys().then(function(keys2) { + return keys2.length; + }); + executeCallback(promise, callback); + return promise; + } + function removeItem$2(key2, callback) { + var self2 = this; + key2 = normalizeKey(key2); + var promise = self2.ready().then(function() { + var dbInfo = self2._dbInfo; + localStorage.removeItem(dbInfo.keyPrefix + key2); + }); + executeCallback(promise, callback); + return promise; + } + function setItem$2(key2, value, callback) { + var self2 = this; + key2 = normalizeKey(key2); + var promise = self2.ready().then(function() { + if (value === void 0) { + value = null; + } + var originalValue = value; + return new Promise$1(function(resolve, reject) { + var dbInfo = self2._dbInfo; + dbInfo.serializer.serialize(value, function(value2, error) { + if (error) { + reject(error); + } else { + try { + localStorage.setItem(dbInfo.keyPrefix + key2, value2); + resolve(originalValue); + } catch (e) { + if (e.name === "QuotaExceededError" || e.name === "NS_ERROR_DOM_QUOTA_REACHED") { + reject(e); + } + reject(e); + } + } + }); + }); + }); + executeCallback(promise, callback); + return promise; + } + function dropInstance$2(options, callback) { + callback = getCallback.apply(this, arguments); + options = typeof options !== "function" && options || {}; + if (!options.name) { + var currentConfig = this.config(); + options.name = options.name || currentConfig.name; + options.storeName = options.storeName || currentConfig.storeName; + } + var self2 = this; + var promise; + if (!options.name) { + promise = Promise$1.reject("Invalid arguments"); + } else { + promise = new Promise$1(function(resolve) { + if (!options.storeName) { + resolve(options.name + "/"); + } else { + resolve(_getKeyPrefix(options, self2._defaultConfig)); + } + }).then(function(keyPrefix) { + for (var i = localStorage.length - 1; i >= 0; i--) { + var key2 = localStorage.key(i); + if (key2.indexOf(keyPrefix) === 0) { + localStorage.removeItem(key2); + } + } + }); + } + executeCallback(promise, callback); + return promise; + } + var localStorageWrapper = { + _driver: "localStorageWrapper", + _initStorage: _initStorage$2, + _support: isLocalStorageValid(), + iterate: iterate$2, + getItem: getItem$2, + setItem: setItem$2, + removeItem: removeItem$2, + clear: clear$2, + length: length$2, + key: key$2, + keys: keys$2, + dropInstance: dropInstance$2 + }; + var sameValue = function sameValue2(x, y) { + return x === y || typeof x === "number" && typeof y === "number" && isNaN(x) && isNaN(y); + }; + var includes = function includes2(array, searchElement) { + var len = array.length; + var i = 0; + while (i < len) { + if (sameValue(array[i], searchElement)) { + return true; + } + i++; + } + return false; + }; + var isArray = Array.isArray || function(arg) { + return Object.prototype.toString.call(arg) === "[object Array]"; + }; + var DefinedDrivers = {}; + var DriverSupport = {}; + var DefaultDrivers = { + INDEXEDDB: asyncStorage, + WEBSQL: webSQLStorage, + LOCALSTORAGE: localStorageWrapper + }; + var DefaultDriverOrder = [DefaultDrivers.INDEXEDDB._driver, DefaultDrivers.WEBSQL._driver, DefaultDrivers.LOCALSTORAGE._driver]; + var OptionalDriverMethods = ["dropInstance"]; + var LibraryMethods = ["clear", "getItem", "iterate", "key", "keys", "length", "removeItem", "setItem"].concat(OptionalDriverMethods); + var DefaultConfig = { + description: "", + driver: DefaultDriverOrder.slice(), + name: "localforage", + // Default DB size is _JUST UNDER_ 5MB, as it's the highest size + // we can use without a prompt. + size: 4980736, + storeName: "keyvaluepairs", + version: 1 + }; + function callWhenReady(localForageInstance, libraryMethod) { + localForageInstance[libraryMethod] = function() { + var _args = arguments; + return localForageInstance.ready().then(function() { + return localForageInstance[libraryMethod].apply(localForageInstance, _args); + }); + }; + } + function extend() { + for (var i = 1; i < arguments.length; i++) { + var arg = arguments[i]; + if (arg) { + for (var _key in arg) { + if (arg.hasOwnProperty(_key)) { + if (isArray(arg[_key])) { + arguments[0][_key] = arg[_key].slice(); + } else { + arguments[0][_key] = arg[_key]; + } + } + } + } + } + return arguments[0]; + } + var LocalForage = (function() { + function LocalForage2(options) { + _classCallCheck(this, LocalForage2); + for (var driverTypeKey in DefaultDrivers) { + if (DefaultDrivers.hasOwnProperty(driverTypeKey)) { + var driver = DefaultDrivers[driverTypeKey]; + var driverName = driver._driver; + this[driverTypeKey] = driverName; + if (!DefinedDrivers[driverName]) { + this.defineDriver(driver); + } + } + } + this._defaultConfig = extend({}, DefaultConfig); + this._config = extend({}, this._defaultConfig, options); + this._driverSet = null; + this._initDriver = null; + this._ready = false; + this._dbInfo = null; + this._wrapLibraryMethodsWithReady(); + this.setDriver(this._config.driver)["catch"](function() { + }); + } + LocalForage2.prototype.config = function config(options) { + if ((typeof options === "undefined" ? "undefined" : _typeof(options)) === "object") { + if (this._ready) { + return new Error("Can't call config() after localforage has been used."); + } + for (var i in options) { + if (i === "storeName") { + options[i] = options[i].replace(/\W/g, "_"); + } + if (i === "version" && typeof options[i] !== "number") { + return new Error("Database version must be a number."); + } + this._config[i] = options[i]; + } + if ("driver" in options && options.driver) { + return this.setDriver(this._config.driver); + } + return true; + } else if (typeof options === "string") { + return this._config[options]; + } else { + return this._config; + } + }; + LocalForage2.prototype.defineDriver = function defineDriver(driverObject, callback, errorCallback) { + var promise = new Promise$1(function(resolve, reject) { + try { + var driverName = driverObject._driver; + var complianceError = new Error("Custom driver not compliant; see https://mozilla.github.io/localForage/#definedriver"); + if (!driverObject._driver) { + reject(complianceError); + return; + } + var driverMethods = LibraryMethods.concat("_initStorage"); + for (var i = 0, len = driverMethods.length; i < len; i++) { + var driverMethodName = driverMethods[i]; + var isRequired = !includes(OptionalDriverMethods, driverMethodName); + if ((isRequired || driverObject[driverMethodName]) && typeof driverObject[driverMethodName] !== "function") { + reject(complianceError); + return; + } + } + var configureMissingMethods = function configureMissingMethods2() { + var methodNotImplementedFactory = function methodNotImplementedFactory2(methodName) { + return function() { + var error = new Error("Method " + methodName + " is not implemented by the current driver"); + var promise2 = Promise$1.reject(error); + executeCallback(promise2, arguments[arguments.length - 1]); + return promise2; + }; + }; + for (var _i = 0, _len = OptionalDriverMethods.length; _i < _len; _i++) { + var optionalDriverMethod = OptionalDriverMethods[_i]; + if (!driverObject[optionalDriverMethod]) { + driverObject[optionalDriverMethod] = methodNotImplementedFactory(optionalDriverMethod); + } + } + }; + configureMissingMethods(); + var setDriverSupport = function setDriverSupport2(support) { + if (DefinedDrivers[driverName]) { + console.info("Redefining LocalForage driver: " + driverName); + } + DefinedDrivers[driverName] = driverObject; + DriverSupport[driverName] = support; + resolve(); + }; + if ("_support" in driverObject) { + if (driverObject._support && typeof driverObject._support === "function") { + driverObject._support().then(setDriverSupport, reject); + } else { + setDriverSupport(!!driverObject._support); + } + } else { + setDriverSupport(true); + } + } catch (e) { + reject(e); + } + }); + executeTwoCallbacks(promise, callback, errorCallback); + return promise; + }; + LocalForage2.prototype.driver = function driver() { + return this._driver || null; + }; + LocalForage2.prototype.getDriver = function getDriver(driverName, callback, errorCallback) { + var getDriverPromise = DefinedDrivers[driverName] ? Promise$1.resolve(DefinedDrivers[driverName]) : Promise$1.reject(new Error("Driver not found.")); + executeTwoCallbacks(getDriverPromise, callback, errorCallback); + return getDriverPromise; + }; + LocalForage2.prototype.getSerializer = function getSerializer(callback) { + var serializerPromise = Promise$1.resolve(localforageSerializer); + executeTwoCallbacks(serializerPromise, callback); + return serializerPromise; + }; + LocalForage2.prototype.ready = function ready(callback) { + var self2 = this; + var promise = self2._driverSet.then(function() { + if (self2._ready === null) { + self2._ready = self2._initDriver(); + } + return self2._ready; + }); + executeTwoCallbacks(promise, callback, callback); + return promise; + }; + LocalForage2.prototype.setDriver = function setDriver(drivers, callback, errorCallback) { + var self2 = this; + if (!isArray(drivers)) { + drivers = [drivers]; + } + var supportedDrivers = this._getSupportedDrivers(drivers); + function setDriverToConfig() { + self2._config.driver = self2.driver(); + } + function extendSelfWithDriver(driver) { + self2._extend(driver); + setDriverToConfig(); + self2._ready = self2._initStorage(self2._config); + return self2._ready; + } + function initDriver(supportedDrivers2) { + return function() { + var currentDriverIndex = 0; + function driverPromiseLoop() { + while (currentDriverIndex < supportedDrivers2.length) { + var driverName = supportedDrivers2[currentDriverIndex]; + currentDriverIndex++; + self2._dbInfo = null; + self2._ready = null; + return self2.getDriver(driverName).then(extendSelfWithDriver)["catch"](driverPromiseLoop); + } + setDriverToConfig(); + var error = new Error("No available storage method found."); + self2._driverSet = Promise$1.reject(error); + return self2._driverSet; + } + return driverPromiseLoop(); + }; + } + var oldDriverSetDone = this._driverSet !== null ? this._driverSet["catch"](function() { + return Promise$1.resolve(); + }) : Promise$1.resolve(); + this._driverSet = oldDriverSetDone.then(function() { + var driverName = supportedDrivers[0]; + self2._dbInfo = null; + self2._ready = null; + return self2.getDriver(driverName).then(function(driver) { + self2._driver = driver._driver; + setDriverToConfig(); + self2._wrapLibraryMethodsWithReady(); + self2._initDriver = initDriver(supportedDrivers); + }); + })["catch"](function() { + setDriverToConfig(); + var error = new Error("No available storage method found."); + self2._driverSet = Promise$1.reject(error); + return self2._driverSet; + }); + executeTwoCallbacks(this._driverSet, callback, errorCallback); + return this._driverSet; + }; + LocalForage2.prototype.supports = function supports(driverName) { + return !!DriverSupport[driverName]; + }; + LocalForage2.prototype._extend = function _extend(libraryMethodsAndProperties) { + extend(this, libraryMethodsAndProperties); + }; + LocalForage2.prototype._getSupportedDrivers = function _getSupportedDrivers(drivers) { + var supportedDrivers = []; + for (var i = 0, len = drivers.length; i < len; i++) { + var driverName = drivers[i]; + if (this.supports(driverName)) { + supportedDrivers.push(driverName); + } + } + return supportedDrivers; + }; + LocalForage2.prototype._wrapLibraryMethodsWithReady = function _wrapLibraryMethodsWithReady() { + for (var i = 0, len = LibraryMethods.length; i < len; i++) { + callWhenReady(this, LibraryMethods[i]); + } + }; + LocalForage2.prototype.createInstance = function createInstance(options) { + return new LocalForage2(options); + }; + return LocalForage2; + })(); + var localforage_js = new LocalForage(); + module4.exports = localforage_js; + }, { "3": 3 }] }, {}, [4])(4); + }); + } +}); + +// src/main.ts +var main_exports = {}; +__export(main_exports, { + default: () => PlantumlPlugin +}); +module.exports = __toCommonJS(main_exports); +var import_obsidian8 = require("obsidian"); + +// src/settings.ts +var import_obsidian = require("obsidian"); +var DEFAULT_SETTINGS = { + server_url: "https://www.plantuml.com/plantuml", + header: "", + debounce: 3, + localJar: "", + javaPath: "java", + dotPath: "dot", + defaultProcessor: "png", + cache: 60, + exportPath: "" +}; +var PlantUMLSettingsTab = class extends import_obsidian.PluginSettingTab { + constructor(plugin) { + super(plugin.app, plugin); + this.plugin = plugin; + } + display() { + const { containerEl } = this; + containerEl.empty(); + new import_obsidian.Setting(containerEl).setName("Server URL").setDesc("PlantUML Server URL").addText( + (text) => text.setPlaceholder(DEFAULT_SETTINGS.server_url).setValue(this.plugin.settings.server_url).onChange( + (value) => __async(this, null, function* () { + this.plugin.settings.server_url = value; + yield this.plugin.saveSettings(); + }) + ) + ); + if (import_obsidian.Platform.isDesktopApp) { + const jarDesc = new DocumentFragment(); + const jarDescDiv = jarDesc.createDiv(); + jarDescDiv.appendText("Path to local JAR"); + jarDescDiv.createEl("br"); + jarDescDiv.appendText("Supports:"); + const jarDescList = jarDescDiv.createEl("ul"); + jarDescList.createEl("li", { text: "Absolute path" }); + jarDescList.createEl("li", { text: "Path relative to vault" }); + const homeDirItem = jarDescList.createEl("li"); + homeDirItem.appendText("Path relative to users home directory "); + homeDirItem.createEl("code", { text: "~/" }); + new import_obsidian.Setting(containerEl).setName("Local JAR").setDesc(jarDesc).addText( + (text) => text.setPlaceholder(DEFAULT_SETTINGS.localJar).setValue(this.plugin.settings.localJar).onChange( + (value) => __async(this, null, function* () { + this.plugin.settings.localJar = value; + yield this.plugin.saveSettings(); + }) + ) + ); + new import_obsidian.Setting(containerEl).setName("Java path").setDesc("Path to Java executable").addText( + (text) => text.setPlaceholder(DEFAULT_SETTINGS.javaPath).setValue(this.plugin.settings.javaPath).onChange( + (value) => __async(this, null, function* () { + this.plugin.settings.javaPath = value; + yield this.plugin.saveSettings(); + }) + ) + ); + new import_obsidian.Setting(containerEl).setName("Dot path").setDesc("Path to dot executable").addText( + (text) => text.setPlaceholder(DEFAULT_SETTINGS.dotPath).setValue(this.plugin.settings.dotPath).onChange( + (value) => __async(this, null, function* () { + this.plugin.settings.dotPath = value; + yield this.plugin.saveSettings(); + }) + ) + ); + new import_obsidian.Setting(containerEl).setName("Diagram export path").setDesc("Path where exported diagrams will be saved relative to the vault root. Leave blank to save along side the note.").addText( + (text) => text.setPlaceholder(DEFAULT_SETTINGS.exportPath).setValue(this.plugin.settings.exportPath).onChange( + (value) => __async(this, null, function* () { + this.plugin.settings.exportPath = value; + yield this.plugin.saveSettings(); + }) + ) + ); + } + new import_obsidian.Setting(containerEl).setName("Default processor for includes").setDesc("Any .pu/.puml files linked will use this processor").addDropdown((dropdown) => { + dropdown.addOption("png", "PNG").addOption("svg", "SVG").setValue(this.plugin.settings.defaultProcessor).onChange((value) => __async(this, null, function* () { + this.plugin.settings.defaultProcessor = value; + yield this.plugin.saveSettings(); + })); + }); + new import_obsidian.Setting(containerEl).setName("Header").setDesc("Included at the head in every diagram. Useful for specifying a common theme (.puml file)").addTextArea( + (text) => { + text.setPlaceholder("!include https://raw.githubusercontent.com/....puml\n").setValue(this.plugin.settings.header).onChange( + (value) => __async(this, null, function* () { + this.plugin.settings.header = value; + yield this.plugin.saveSettings(); + }) + ); + text.inputEl.setAttr("rows", 4); + text.inputEl.addClass("puml-settings-area"); + } + ); + new import_obsidian.Setting(containerEl).setName("Cache").setDesc("in days. Only applicable when generating diagrams locally").addSlider((slider) => { + slider.setLimits(10, 360, 10).setValue(this.plugin.settings.cache).setDynamicTooltip().onChange((value) => __async(this, null, function* () { + this.plugin.settings.cache = value; + yield this.plugin.saveSettings(); + })); + }); + new import_obsidian.Setting(containerEl).setName("Debounce").setDesc("How often should the diagram refresh in seconds").addText((text) => text.setPlaceholder(String(DEFAULT_SETTINGS.debounce)).setValue(String(this.plugin.settings.debounce)).onChange((value) => __async(this, null, function* () { + if (!isNaN(Number(value)) || value === void 0) { + this.plugin.settings.debounce = Number(value || DEFAULT_SETTINGS.debounce); + yield this.plugin.saveSettings(); + } else { + new import_obsidian.Notice("Please specify a valid number"); + } + }))); + } +}; + +// src/processors/localProcessors.ts +var import_obsidian3 = require("obsidian"); +var plantuml = __toESM(require_browser_index()); + +// src/functions.ts +var import_obsidian2 = require("obsidian"); +var Replacer = class { + constructor(plugin) { + this.plugin = plugin; + } + decodeWhiteSpaces(text) { + return text.replace(/ /gi, " "); + } + /** + * replace all links in the plugin syntax with valid plantuml links to note inside the vault + * @param text the text, in which to replace all links + * @param path path of the current file + * @param filetype + */ + replaceLinks(text, path, filetype) { + return text.replace(/\[\[\[([\s\S]*?)\]\]\]/g, ((_, args) => { + const split = args.split("|"); + const file = this.plugin.app.metadataCache.getFirstLinkpathDest(split[0], path); + if (!file) { + return "File with name: " + split[0] + " not found"; + } + let alias = file.basename; + if (filetype === "png") { + const url = this.plugin.app.getObsidianUrl(file); + if (split[1]) { + alias = split[1]; + } + return "[[" + url + " " + alias + "]]"; + } + return "[[" + file.basename + "]]"; + })); + } + /** + * get the absolute path on the users computer + * @param path vault local path + */ + getFullPath(path) { + var _a; + if (!(this.plugin.app.vault.adapter instanceof import_obsidian2.FileSystemAdapter)) { + return; + } + if (path.length === 0) { + return this.plugin.app.vault.adapter.getFullPath(""); + } + const file = this.plugin.app.vault.getAbstractFileByPath(path); + if (!file) { + return this.plugin.app.vault.adapter.getFullPath(""); + } + const vault = this.plugin.app.vault; + const folder = vault.getDirectParent(file); + return this.plugin.app.vault.adapter.getFullPath((_a = folder == null ? void 0 : folder.path) != null ? _a : ""); + } + getPath(ctx) { + return this.getFullPath(ctx ? ctx.sourcePath : ""); + } +}; +function insertImageWithMap(el, image, map, encodedDiagram) { + el.empty(); + const img = el.createEl("img"); + if (image.startsWith("http")) { + img.src = image; + } else { + img.src = "data:image/png;base64," + image; + } + img.useMap = "#" + encodedDiagram; + if (map.contains("map")) { + const parser = new DOMParser(); + const mapDoc = parser.parseFromString(map, "text/html"); + const mapEl = mapDoc.body.firstChild; + if (mapEl) { + const cloned = mapEl.cloneNode(true); + cloned.setAttr("name", encodedDiagram); + el.appendChild(cloned); + } + } +} +function insertAsciiImage(el, image) { + el.empty(); + const pre = el.createEl("pre"); + const code = pre.createEl("code"); + code.setText(image); +} +function insertSvgImage(el, image) { + el.empty(); + const parser = new DOMParser(); + const svg = parser.parseFromString(image, "image/svg+xml"); + const links = svg.getElementsByTagName("a"); + for (let i = 0; i < links.length; i++) { + const link = links[i]; + link.addClass("internal-link"); + } + el.appendChild(activeDocument.importNode(svg.documentElement, true)); +} + +// src/const.ts +var LOGO_SVG = ''; + +// src/processors/localProcessors.ts +var localforage = __toESM(require_localforage()); +var exec; +var Buffer2; +var pathModule; +var osModule; +function loadNodeModules() { + return __async(this, null, function* () { + if (import_obsidian3.Platform.isDesktop && !exec) { + const nodeRequire = window.require; + exec = nodeRequire("child_process").exec; + Buffer2 = nodeRequire("buffer").Buffer; + pathModule = nodeRequire("path"); + osModule = nodeRequire("os"); + } + }); +} +var LocalProcessors = class { + constructor(plugin) { + this.ascii = (source, el, ctx) => __async(this, null, function* () { + if (!import_obsidian3.Platform.isDesktop) { + throw new Error("Local processing is only available on desktop"); + } + yield loadNodeModules(); + const encodedDiagram = plantuml.encode(source); + const item = yield localforage.getItem("ascii-" + encodedDiagram); + if (item) { + insertAsciiImage(el, item); + yield localforage.setItem("ts-" + encodedDiagram, Date.now()); + return; + } + const image = yield this.generateLocalImage(source, "txt" /* ASCII */, this.plugin.replacer.getPath(ctx)); + insertAsciiImage(el, image); + yield localforage.setItem("ascii-" + encodedDiagram, image); + yield localforage.setItem("ts-" + encodedDiagram, Date.now()); + }); + this.png = (source, el, ctx) => __async(this, null, function* () { + if (!import_obsidian3.Platform.isDesktop) { + throw new Error("Local processing is only available on desktop"); + } + yield loadNodeModules(); + const encodedDiagram = plantuml.encode(source); + const item = yield localforage.getItem("png-" + encodedDiagram); + if (item) { + const map2 = yield localforage.getItem("map-" + encodedDiagram); + insertImageWithMap(el, item, map2, encodedDiagram); + yield localforage.setItem("ts-" + encodedDiagram, Date.now()); + return; + } + const path = this.plugin.replacer.getPath(ctx); + const image = yield this.generateLocalImage(source, "png" /* PNG */, path); + const map = yield this.generateLocalMap(source, path); + yield localforage.setItem("png-" + encodedDiagram, image); + yield localforage.setItem("map-" + encodedDiagram, map); + yield localforage.setItem("ts-" + encodedDiagram, Date.now()); + insertImageWithMap(el, image, map, encodedDiagram); + }); + this.svg = (source, el, ctx) => __async(this, null, function* () { + if (!import_obsidian3.Platform.isDesktop) { + throw new Error("Local processing is only available on desktop"); + } + yield loadNodeModules(); + const encodedDiagram = plantuml.encode(source); + const item = yield localforage.getItem("svg-" + encodedDiagram); + if (item) { + insertSvgImage(el, item); + yield localforage.setItem("ts-" + encodedDiagram, Date.now()); + return; + } + const image = yield this.generateLocalImage(source, "svg" /* SVG */, this.plugin.replacer.getPath(ctx)); + yield localforage.setItem("svg-" + encodedDiagram, image); + yield localforage.setItem("ts-" + encodedDiagram, Date.now()); + insertSvgImage(el, image); + }); + this.plugin = plugin; + } + generateLocalMap(source, path) { + return __async(this, null, function* () { + if (!import_obsidian3.Platform.isDesktop) { + throw new Error("Local processing is only available on desktop"); + } + const args = yield this.resolveLocalJarCmd(); + const child = exec(args.concat(["-pipemap"]).join(" "), { encoding: "binary", cwd: path }); + let stdout = ""; + if (child.stdout) { + child.stdout.on("data", (data) => { + stdout += data; + }); + } + return new Promise((resolve, reject) => { + var _a, _b; + child.on("error", reject); + child.on("close", (code) => { + if (code === 0) { + resolve(stdout); + return; + } else if (code === 1) { + console.error(stdout); + reject(new Error(`an error occurred`)); + } else { + reject(new Error(`child exited with code ${String(code)}`)); + } + }); + (_a = child.stdin) == null ? void 0 : _a.write(source); + (_b = child.stdin) == null ? void 0 : _b.end(); + }); + }); + } + generateLocalImage(source, type, path) { + return __async(this, null, function* () { + if (!import_obsidian3.Platform.isDesktop) { + throw new Error("Local processing is only available on desktop"); + } + const args = yield this.resolveLocalJarCmd(); + const cmdArgs = args.concat(["-t" + type, "-pipe"]); + const child = exec(cmdArgs.join(" "), { + encoding: type === "png" /* PNG */ ? "binary" : "utf-8", + cwd: path + }); + let stdout = null; + let stderr = null; + if (child.stdout) { + child.stdout.on("data", (data) => { + stdout = stdout === null ? data : stdout + data; + }); + } + if (child.stderr) { + child.stderr.on("data", (data) => { + stderr = stderr === null ? data : stderr + data; + }); + } + return new Promise((resolve, reject) => { + var _a, _b; + child.on("error", reject); + child.on("close", (code) => { + if (stdout === null) { + return; + } + if (code === 0) { + if (type === "png" /* PNG */) { + resolve(Buffer2.from(stdout, "binary").toString("base64")); + return; + } + resolve(stdout); + return; + } else if (code === 1) { + console.error(stdout); + reject(new Error(stderr != null ? stderr : "")); + } else { + if (type === "png" /* PNG */) { + resolve(Buffer2.from(stdout, "binary").toString("base64")); + return; + } + resolve(stdout); + } + }); + (_a = child.stdin) == null ? void 0 : _a.write(source, "utf-8"); + (_b = child.stdin) == null ? void 0 : _b.end(); + }); + }); + } + /** + * To support local jar settings with unix-like style, and search local jar file + * from current vault path. + */ + resolveLocalJarCmd() { + return __async(this, null, function* () { + if (!import_obsidian3.Platform.isDesktop) { + throw new Error("Local processing is only available on desktop"); + } + const jarFromSettings = this.plugin.settings.localJar; + let jarFullPath; + const path = this.plugin.replacer.getFullPath(""); + if (jarFromSettings[0] === "~") { + jarFullPath = osModule.userInfo().homedir + jarFromSettings.slice(1); + } else { + if (pathModule.isAbsolute(jarFromSettings)) { + jarFullPath = jarFromSettings; + } else { + jarFullPath = pathModule.resolve(path, jarFromSettings); + } + } + if (jarFullPath.length == 0) { + throw Error("Invalid local jar file"); + } + if (jarFullPath.endsWith(".jar")) { + return [ + this.plugin.settings.javaPath, + "-jar", + "-Djava.awt.headless=true", + '"' + jarFullPath + '"', + "-charset", + "utf-8", + "-graphvizdot", + '"' + this.plugin.settings.dotPath + '"' + ]; + } + return [ + jarFullPath, + "-Djava.awt.headless=true", + "-charset", + "utf-8", + "-graphvizdot", + '"' + this.plugin.settings.dotPath + '"' + ]; + }); + } +}; + +// src/processors/debouncedProcessors.ts +var import_obsidian4 = require("obsidian"); + +// node_modules/uuid/dist/stringify.js +var byteToHex = []; +for (let i = 0; i < 256; ++i) { + byteToHex.push((i + 256).toString(16).slice(1)); +} +function unsafeStringify(arr, offset = 0) { + return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); +} + +// node_modules/uuid/dist/rng.js +var rnds8 = new Uint8Array(16); +function rng() { + return crypto.getRandomValues(rnds8); +} + +// node_modules/uuid/dist/v4.js +function v4(options, buf, offset) { + if (!buf && !options && crypto.randomUUID) { + return crypto.randomUUID(); + } + return _v4(options, buf, offset); +} +function _v4(options, buf, offset) { + var _a, _b, _c; + options = options || {}; + const rnds = (_c = (_b = options.random) != null ? _b : (_a = options.rng) == null ? void 0 : _a.call(options)) != null ? _c : rng(); + if (rnds.length < 16) { + throw new Error("Random bytes length must be >= 16"); + } + rnds[6] = rnds[6] & 15 | 64; + rnds[8] = rnds[8] & 63 | 128; + if (buf) { + offset = offset || 0; + if (offset < 0 || offset + 16 > buf.length) { + throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`); + } + for (let i = 0; i < 16; ++i) { + buf[offset + i] = rnds[i]; + } + return buf; + } + return unsafeStringify(rnds); +} +var v4_default = v4; + +// src/processors/debouncedProcessors.ts +var DebouncedProcessors = class { + constructor(plugin) { + this.SECONDS_TO_MS_FACTOR = 1e3; + this.debounceMap = /* @__PURE__ */ new Map(); + this.default = (source, el, ctx) => __async(this, null, function* () { + yield this.png(source, el, ctx); + }); + this.png = (source, el, ctx) => __async(this, null, function* () { + yield this.processor(source, el, ctx, "png", this.plugin.getProcessor().png); + }); + this.ascii = (source, el, ctx) => __async(this, null, function* () { + yield this.processor(source, el, ctx, "ascii", this.plugin.getProcessor().ascii); + }); + this.svg = (source, el, ctx) => __async(this, null, function* () { + yield this.processor(source, el, ctx, "svg", this.plugin.getProcessor().svg); + }); + this.processor = (source, el, ctx, filetype, processor) => __async(this, null, function* () { + const originalSource = source; + el.dataset.filetype = filetype; + el.createEl("h6", { text: "Generating PlantUML diagram", cls: "puml-loading" }); + if (el.dataset.plantumlDebounce) { + const debounceId = el.dataset.plantumlDebounce; + if (this.debounceMap.has(debounceId)) { + this.debounceMap.get(debounceId)(source, el, ctx); + } + } else { + const func = (0, import_obsidian4.debounce)(processor, this.debounceTime, true); + const uuid = v4_default(); + el.dataset.plantumlDebouce = uuid; + this.debounceMap.set(uuid, func); + source = this.plugin.replacer.decodeWhiteSpaces(source); + source = this.plugin.replacer.replaceLinks(source, this.plugin.replacer.getPath(ctx), filetype); + source = this.plugin.settings.header + "\r\n" + source; + yield processor(source, el, ctx); + el.addEventListener("contextmenu", (event) => { + const menu = new import_obsidian4.Menu().addItem((item) => { + item.setTitle("Copy diagram source").setIcon("clipboard-copy").onClick(() => __async(this, null, function* () { + yield navigator.clipboard.writeText(originalSource); + })); + }).addItem((item) => { + item.setTitle("Copy diagram").setIcon("image").onClick(() => __async(this, null, function* () { + const img = el.querySelector("img"); + if (img) { + this.renderToBlob( + img, + "An error occurred while copying image to clipboard", + (blob) => __async(this, null, function* () { + yield navigator.clipboard.write([ + new ClipboardItem({ + "image/png": blob + }) + ]); + new import_obsidian4.Notice("Diagram copied to clipboard"); + }) + ); + } + const svg = el.querySelector("svg"); + if (svg) { + yield navigator.clipboard.writeText(svg.outerHTML.replace(/ /g, "")); + new import_obsidian4.Notice("Diagram copied to clipboard"); + } + const code = el.querySelector("code"); + if (code) { + yield navigator.clipboard.writeText(code.innerText); + new import_obsidian4.Notice("Diagram copied to clipboard"); + } + })); + }).addItem((item) => { + item.setTitle("Export diagram").setIcon("image-file").onClick(() => __async(this, null, function* () { + const img = el.querySelector("img"); + if (img) { + this.renderToBlob(img, "An error occurred while exporting the diagram", (blob) => __async(this, null, function* () { + const filename = yield this.getFilePath(source, ctx, "png"); + const buffer = yield blob.arrayBuffer(); + const file = this.getFile(filename); + if (file) { + yield this.plugin.app.vault.modifyBinary(file, buffer); + } else { + yield this.plugin.app.vault.createBinary(filename, buffer); + } + new import_obsidian4.Notice(`Diagram exported to '${filename}'`); + })); + } + const svg = el.querySelector("svg"); + if (svg) { + yield this.saveTextFile(source, ctx, "svg", svg.outerHTML); + } + const code = el.querySelector("code"); + if (code) { + yield this.saveTextFile(source, ctx, "txt", code.innerText); + } + })); + }); + menu.showAtMouseEvent(event); + }); + } + }); + this.renderToBlob = (img, errorMessage, handleBlob) => { + const image = new Image(); + image.crossOrigin = "anonymous"; + image.src = img.src; + image.addEventListener("load", () => { + const canvas = activeDocument.createEl("canvas"); + canvas.width = image.width; + canvas.height = image.height; + const ctx = canvas.getContext("2d"); + ctx.fillStyle = "#fff"; + ctx.fillRect(0, 0, canvas.width, canvas.height); + ctx.drawImage(image, 0, 0); + try { + canvas.toBlob((blob) => { + if (!blob) return; + handleBlob(blob).catch(() => { + new import_obsidian4.Notice(errorMessage); + }); + }); + } catch (error) { + new import_obsidian4.Notice(errorMessage); + console.error(error); + } + }); + }; + this.getFilename = (source, ctx) => { + const startuml = source.match(/@startuml (.+)/i); + if ((startuml == null ? void 0 : startuml.length) >= 2) { + return `${startuml[1].trim()}`; + } + const now = (/* @__PURE__ */ new Date()).toISOString().replace(/[:T]+/g, "-"); + const filename = this.plugin.app.vault.getAbstractFileByPath(ctx.sourcePath).name; + return `${filename.substring(0, filename.lastIndexOf("."))}-${now.substring(0, now.lastIndexOf("."))}`; + }; + this.getFolder = (ctx) => __async(this, null, function* () { + let exportPath = this.plugin.settings.exportPath; + if (!exportPath.startsWith("/")) { + const documentPath = this.plugin.app.vault.getAbstractFileByPath(ctx.sourcePath).parent; + exportPath = `${documentPath.path}/${exportPath}`; + } + const exists = yield this.plugin.app.vault.adapter.exists(exportPath); + if (!exists) { + yield this.plugin.app.vault.createFolder(exportPath); + } + return exportPath; + }); + this.getFilePath = (source, ctx, type) => __async(this, null, function* () { + const filename = this.getFilename(source, ctx); + const path = yield this.getFolder(ctx); + return `${path}${filename}.${type}`; + }); + this.getFile = (fileName) => { + let fName = fileName; + if (fName.startsWith("/")) { + fName = fName.substring(1); + } + const folderOrFile = this.plugin.app.vault.getAbstractFileByPath(fName); + if (folderOrFile instanceof import_obsidian4.TFile) { + return folderOrFile; + } + return void 0; + }; + this.saveTextFile = (source, ctx, type, data) => __async(this, null, function* () { + try { + const filename = yield this.getFilePath(source, ctx, type); + const file = this.getFile(filename); + if (file) { + yield this.plugin.app.vault.modify(file, data); + } else { + yield this.plugin.app.vault.create(filename, data); + } + new import_obsidian4.Notice(`Diagram exported to '${filename}'`); + } catch (error) { + new import_obsidian4.Notice("An error occurred while while exporting the diagram"); + console.error(error); + } + }); + this.plugin = plugin; + const debounceTime = plugin.settings.debounce; + this.debounceTime = debounceTime * this.SECONDS_TO_MS_FACTOR; + } +}; + +// src/processors/serverProcessor.ts +var import_obsidian5 = require("obsidian"); +var plantuml2 = __toESM(require_browser_index()); +var ServerProcessor = class { + constructor(plugin) { + this.svg = (source, el, _) => __async(this, null, function* () { + let url = this.plugin.settings.server_url; + if (url.length == 0) { + url = DEFAULT_SETTINGS.server_url; + } + const imageUrlBase = url + "/svg/"; + const encodedDiagram = plantuml2.encode(source); + (0, import_obsidian5.request)({ url: imageUrlBase + encodedDiagram, method: "GET" }).then((value) => { + insertSvgImage(el, value); + }).catch((error) => { + if (error) + console.error(error); + }); + }); + this.png = (source, el, _) => __async(this, null, function* () { + let url = this.plugin.settings.server_url; + if (url.length == 0) { + url = DEFAULT_SETTINGS.server_url; + } + const imageUrlBase = url + "/png/"; + const encodedDiagram = plantuml2.encode(source); + const image = imageUrlBase + encodedDiagram; + const mapUrlBase = url + "/map/"; + const map = yield (0, import_obsidian5.request)({ url: mapUrlBase + encodedDiagram, method: "GET" }); + insertImageWithMap(el, image, map, encodedDiagram); + }); + this.ascii = (source, el, _) => __async(this, null, function* () { + let url = this.plugin.settings.server_url; + if (url.length == 0) { + url = DEFAULT_SETTINGS.server_url; + } + const asciiUrlBase = url + "/txt/"; + const encodedDiagram = plantuml2.encode(source); + const result = yield (0, import_obsidian5.request)({ url: asciiUrlBase + encodedDiagram }); + if (result.startsWith("\uFFFDPNG")) { + const text = activeDocument.createEl("p"); + text.addClass("mod-error"); + text.innerText = "Your configured PlantUML Server does not support ASCII Art"; + el.appendChild(text); + return; + } + insertAsciiImage(el, result); + }); + this.plugin = plugin; + } +}; + +// src/PumlView.ts +var import_obsidian6 = require("obsidian"); +var import_view = require("@codemirror/view"); +var import_state = require("@codemirror/state"); +var import_search = require("@codemirror/search"); +var import_commands = require("@codemirror/commands"); +var VIEW_TYPE = "plantuml"; +var views = []; +var syncAnnotation = import_state.Annotation.define(); +function syncDispatch(from) { + return (tr) => { + views[from].update([tr]); + if (tr.changes && tr.annotation && !tr.changes.empty && !tr.annotation(syncAnnotation)) { + for (let i = 0; i < views.length; i++) { + if (i !== from) { + views[i].dispatch({ + changes: tr.changes, + annotations: syncAnnotation.of(true) + }); + } + } + } + }; +} +var PumlView = class extends import_obsidian6.TextFileView { + constructor(leaf, plugin) { + super(leaf); + this.dispatchId = -1; + this.extensions = [ + (0, import_view.highlightActiveLine)(), + (0, import_view.highlightActiveLineGutter)(), + (0, import_search.highlightSelectionMatches)(), + (0, import_view.drawSelection)(), + import_view.keymap.of([...import_commands.defaultKeymap, import_commands.indentWithTab]), + (0, import_commands.history)(), + (0, import_search.search)(), + import_view.EditorView.updateListener.of((v) => { + if (v.docChanged) { + this.requestSave(); + void this.renderPreview(); + } + }) + ]; + this.plugin = plugin; + this.debounced = (0, import_obsidian6.debounce)(this.plugin.getProcessor().png, this.plugin.settings.debounce * 1e3, true); + this.sourceEl = this.contentEl.createDiv({ cls: "plantuml-source-view", attr: { "style": "display: block" } }); + this.previewEl = this.contentEl.createDiv({ cls: "plantuml-preview-view", attr: { "style": "display: none" } }); + const vault = this.app.vault; + if (vault.getConfig("showLineNumber")) { + this.extensions.push((0, import_view.lineNumbers)()); + } + if (vault.getConfig("lineWrap")) { + this.extensions.push(import_view.EditorView.lineWrapping); + } + this.editor = new import_view.EditorView({ + state: import_state.EditorState.create({ + extensions: this.extensions, + doc: this.data + }), + parent: this.sourceEl, + dispatch: syncDispatch(views.length) + }); + this.dispatchId = views.push(this.editor) - 1; + } + getViewType() { + return VIEW_TYPE; + } + getState() { + return super.getState(); + } + setState(state, result) { + if (state.mode === "preview") { + this.currentView = "preview"; + (0, import_obsidian6.setIcon)(this.changeModeButton, "pencil"); + this.changeModeButton.setAttribute("aria-label", "Edit (Ctrl+Click to edit in new pane)"); + this.previewEl.show(); + this.sourceEl.hide(); + void this.renderPreview(); + } else { + this.currentView = "source"; + (0, import_obsidian6.setIcon)(this.changeModeButton, "lines-of-text"); + this.changeModeButton.setAttribute("aria-label", "Preview (Ctrl+Click to open in new pane)"); + this.previewEl.hide(); + this.sourceEl.show(); + } + return super.setState(state, result); + } + onload() { + void this._onload(); + } + _onload() { + return __async(this, null, function* () { + this.changeModeButton = this.addAction("lines-of-text", "Preview (Ctrl+Click to open in new pane)", (evt) => this.switchMode(evt), 17); + const vault = this.app.vault; + const defaultViewMode = vault.getConfig("defaultViewMode"); + this.currentView = defaultViewMode; + yield this.setState(__spreadProps(__spreadValues({}, this.getState()), { mode: defaultViewMode }), {}); + }); + } + onunload() { + views.remove(views[this.dispatchId]); + this.editor.destroy(); + } + // function to switch between source and preview mode + switchMode(arg) { + return __async(this, null, function* () { + let mode = arg; + if (!mode || mode instanceof MouseEvent) mode = this.currentView === "source" ? "preview" : "source"; + if (arg instanceof MouseEvent) { + if (import_obsidian6.Keymap.isModEvent(arg)) { + const newLeaf = this.app.workspace.getLeaf("tab"); + const currentState = this.getState(); + void newLeaf.setViewState({ + type: VIEW_TYPE, + state: __spreadProps(__spreadValues({}, typeof currentState === "object" && currentState !== null ? currentState : {}), { + mode + }) + }); + } else { + const currentState = this.getState(); + yield this.setState(__spreadProps(__spreadValues({}, typeof currentState === "object" && currentState !== null ? currentState : {}), { + mode + }), {}); + } + } + }); + } + // get the data for save + getViewData() { + return this.editor.state.sliceDoc(); + } + // load the data into the view + setViewData(data, clear) { + this.data = data; + if (clear) { + this.editor.setState(import_state.EditorState.create({ + doc: data, + extensions: this.extensions + })); + } else { + this.editor.dispatch({ + changes: { + from: 0, + to: this.editor.state.doc.length, + insert: data + } + }); + } + if (this.currentView === "preview") void this.renderPreview(); + } + // clear the editor, etc + clear() { + this.previewEl.empty(); + this.data = null; + } + getDisplayText() { + if (this.file) return this.file.basename; + else return "PlantUML (no file)"; + } + canAcceptExtension(extension) { + return extension == "puml"; + } + getIcon() { + return "document-plantuml"; + } + renderPreview() { + return __async(this, null, function* () { + if (this.currentView !== "preview") return; + this.previewEl.empty(); + const loadingHeader = this.previewEl.createEl("h1", { text: "Loading" }); + const previewDiv = this.previewEl.createDiv(); + this.debounced(this.getViewData(), previewDiv, null); + loadingHeader.remove(); + }); + } +}; + +// src/main.ts +var import_localforage = __toESM(require_localforage()); + +// src/embed.ts +var import_obsidian7 = require("obsidian"); +var PumlEmbed = class extends import_obsidian7.Component { + constructor(plugin, file, ctx) { + super(); + this.plugin = plugin; + this.file = file; + this.ctx = ctx; + } + loadFile() { + return __async(this, null, function* () { + const data = yield this.plugin.app.vault.cachedRead(this.file); + yield this.plugin.getProcessor().png(data, this.ctx.containerEl, null); + }); + } +}; + +// src/main.ts +var PlantumlPlugin = class extends import_obsidian8.Plugin { + constructor() { + super(...arguments); + this.hover = { + linkText: null, + sourcePath: null + }; + } + getProcessor() { + if (import_obsidian8.Platform.isMobileApp) { + return this.serverProcessor; + } + if (this.settings.localJar.length > 0) { + return this.localProcessor; + } + return this.serverProcessor; + } + onload() { + void this.loadSettings().then(() => __async(this, null, function* () { + this.addSettingTab(new PlantUMLSettingsTab(this)); + this.replacer = new Replacer(this); + this.serverProcessor = new ServerProcessor(this); + if (import_obsidian8.Platform.isDesktopApp) { + this.localProcessor = new LocalProcessors(this); + } + const processor = new DebouncedProcessors(this); + (0, import_obsidian8.addIcon)("document-" + VIEW_TYPE, LOGO_SVG); + this.registerView(VIEW_TYPE, (leaf) => { + return new PumlView(leaf, this); + }); + this.registerExtensions(["puml", "pu"], VIEW_TYPE); + this.registerMarkdownCodeBlockProcessor("plantuml", processor.default); + this.registerMarkdownCodeBlockProcessor("plantuml-png", processor.png); + this.registerMarkdownCodeBlockProcessor("plantuml-ascii", processor.ascii); + this.registerMarkdownCodeBlockProcessor("plantuml-svg", processor.svg); + this.registerMarkdownCodeBlockProcessor("puml", processor.default); + this.registerMarkdownCodeBlockProcessor("puml-png", processor.png); + this.registerMarkdownCodeBlockProcessor("puml-svg", processor.svg); + this.registerMarkdownCodeBlockProcessor("puml-ascii", processor.ascii); + this.registerMarkdownCodeBlockProcessor("plantuml-map", processor.png); + this.app.embedRegistry.registerExtensions(["puml", "pu"], (ctx, file, _subpath) => new PumlEmbed(this, file, ctx)); + this.cleanupLocalStorage(); + import_localforage.default.config({ + name: "puml", + description: "PlantUML plugin" + }); + yield this.cleanupCache(); + this.observer = new MutationObserver((mutations) => { + void this._handleHoverMutation(mutations); + }); + this.registerEvent(this.app.workspace.on("hover-link", (event) => { + const hoverEvent = event; + const linkText = hoverEvent.linktext; + if (!linkText) return; + const sourcePath = hoverEvent.sourcePath; + if (!linkText.endsWith(".puml") && !linkText.endsWith(".pu")) { + return; + } + this.hover.linkText = linkText; + this.hover.sourcePath = sourcePath; + })); + this.observer.observe(activeDocument, { childList: true, subtree: true }); + })); + } + _handleHoverMutation(mutations) { + return __async(this, null, function* () { + if (mutations.length !== 1) return; + if (mutations[0].addedNodes.length !== 1) return; + if (this.hover.linkText === null) return; + if (mutations[0].addedNodes[0].className !== "popover hover-popover file-embed is-loaded") return; + const file = this.app.metadataCache.getFirstLinkpathDest(this.hover.linkText, this.hover.sourcePath); + if (!file) return; + if (file.extension !== "puml" && file.extension !== "pu") return; + const fileContent = yield this.app.vault.read(file); + const imgDiv = createDiv(); + if (this.settings.defaultProcessor === "png") { + yield this.getProcessor().png(fileContent, imgDiv, null); + } else { + yield this.getProcessor().svg(fileContent, imgDiv, null); + } + const node = mutations[0].addedNodes[0]; + node.empty(); + const div = createDiv("", (element) => { + element.appendChild(imgDiv); + element.setAttribute("src", file.path); + element.onClickEvent(((event) => { + event.stopImmediatePropagation(); + const leaf = this.app.workspace.getLeaf(event.ctrlKey); + void leaf.setViewState({ + type: VIEW_TYPE, + state: { file: file.path } + }); + })); + }); + node.appendChild(div); + }); + } + cleanupCache() { + return __async(this, null, function* () { + yield import_localforage.default.iterate((value, key) => { + if (key.startsWith("ts-")) { + const encoded = key.split("-")[1]; + if (value < (/* @__PURE__ */ new Date()).getTime() - this.settings.cache * 24 * 60 * 60 * 1e3) { + void import_localforage.default.removeItem("png-" + encoded); + void import_localforage.default.removeItem("svg-" + encoded); + void import_localforage.default.removeItem("map-" + encoded); + void import_localforage.default.removeItem("ascii-" + encoded); + } + } + }); + }); + } + /* + * older versions used to store generated images in local storage when using local generation. + * To fix issues with the local storage quota we have to clean this up when upgrading from a version that supported this. + */ + cleanupLocalStorage() { + for (const key of Object.keys(window.localStorage)) { + if (key.endsWith("-map") || key.endsWith("-png") || key.endsWith("-svg") || key.endsWith("ascii")) { + window.localStorage.removeItem(key); + } + } + } + onunload() { + this.observer.disconnect(); + this.app.embedRegistry.unregisterExtensions(["puml", "pu"]); + } + loadSettings() { + return __async(this, null, function* () { + this.settings = Object.assign({}, DEFAULT_SETTINGS, yield this.loadData()); + }); + } + saveSettings() { + return __async(this, null, function* () { + yield this.saveData(this.settings); + }); + } + onExternalSettingsChange() { + return __async(this, null, function* () { + yield this.loadSettings(); + }); + } +}; +/*! Bundled license information: + +localforage/dist/localforage.js: + (*! + localForage -- Offline Storage, Improved + Version 1.10.0 + https://localforage.github.io/localForage + (c) 2013-2017 Mozilla, Apache License 2.0 + *) +*/ + +/* nosourcemap */ \ No newline at end of file diff --git a/.obsidian/plugins/obsidian-plantuml/manifest.json b/.obsidian/plugins/obsidian-plantuml/manifest.json new file mode 100644 index 0000000..5165cd9 --- /dev/null +++ b/.obsidian/plugins/obsidian-plantuml/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "obsidian-plantuml", + "name": "PlantUML", + "version": "1.8.1", + "minAppVersion": "1.12.3", + "description": "Render PlantUML diagrams.", + "author": "Johannes Theiner", + "authorUrl": "https://github.com/joethei/", + "isDesktopOnly": false +} diff --git a/.obsidian/plugins/obsidian-plantuml/styles.css b/.obsidian/plugins/obsidian-plantuml/styles.css new file mode 100644 index 0000000..78e8487 --- /dev/null +++ b/.obsidian/plugins/obsidian-plantuml/styles.css @@ -0,0 +1,38 @@ +.puml-settings-area { + margin-left: 5px; + margin-right: 5px; + font-size: 14px; + width: 100%; +} + +.plantuml-source-view .cm-activeLine { + background-color: unset !important; +} + +.plantuml-source-view .cm-gutters { + background-color: unset !important; +} + +.plantuml-source-view .cm-cursor { + border-left: 1.2px solid var(--text-muted); +} + +.plantuml-source-view .cm-selectionBackground { + background-color: var(--text-selection) !important; +} + +.puml-loading { + color: var(--text-accent); +} + +.internal-embed.file-embed[src$=".puml"] { + display: none; +} + +.internal-embed.file-embed[src$=".pu"] { + display: none; +} + +.puml-error { + color: var(--text-error); +} diff --git a/.obsidian/workspace.json b/.obsidian/workspace.json new file mode 100644 index 0000000..042cbd7 --- /dev/null +++ b/.obsidian/workspace.json @@ -0,0 +1,202 @@ +{ + "main": { + "id": "34322ec98fe4ace0", + "type": "split", + "children": [ + { + "id": "f445e7e4c04b6d6c", + "type": "tabs", + "children": [ + { + "id": "b0ba3684f585064f", + "type": "leaf", + "state": { + "type": "markdown", + "state": { + "file": "部门五月份任务规划.md", + "mode": "preview", + "source": false + }, + "icon": "lucide-file", + "title": "部门五月份任务规划" + } + } + ] + } + ], + "direction": "vertical" + }, + "left": { + "id": "f28f404232152be7", + "type": "split", + "children": [ + { + "id": "4e21676eaea216de", + "type": "tabs", + "children": [ + { + "id": "e83b0cf4717abffd", + "type": "leaf", + "state": { + "type": "file-explorer", + "state": { + "sortOrder": "alphabetical", + "autoReveal": false + }, + "icon": "lucide-folder-closed", + "title": "文件列表" + } + }, + { + "id": "03cbd748b4dbc76d", + "type": "leaf", + "state": { + "type": "search", + "state": { + "query": "", + "matchingCase": false, + "explainSearch": false, + "collapseAll": false, + "extraContext": false, + "sortOrder": "alphabetical" + }, + "icon": "lucide-search", + "title": "搜索" + } + }, + { + "id": "f360c2ef69c76b82", + "type": "leaf", + "state": { + "type": "bookmarks", + "state": {}, + "icon": "lucide-bookmark", + "title": "书签" + } + } + ] + } + ], + "direction": "horizontal", + "width": 300 + }, + "right": { + "id": "b1c9737c4bc03c53", + "type": "split", + "children": [ + { + "id": "ca19b47a1eeb9d04", + "type": "tabs", + "children": [ + { + "id": "0be192ae856e2d5b", + "type": "leaf", + "state": { + "type": "backlink", + "state": { + "file": "部门五月份任务规划.md", + "collapseAll": false, + "extraContext": false, + "sortOrder": "alphabetical", + "showSearch": false, + "searchQuery": "", + "backlinkCollapsed": false, + "unlinkedCollapsed": true + }, + "icon": "links-coming-in", + "title": "部门五月份任务规划 的反向链接列表" + } + }, + { + "id": "3a0ea5aa43c4390f", + "type": "leaf", + "state": { + "type": "outgoing-link", + "state": { + "file": "部门五月份任务规划.md", + "linksCollapsed": false, + "unlinkedCollapsed": true + }, + "icon": "links-going-out", + "title": "部门五月份任务规划 的出链列表" + } + }, + { + "id": "5ff1ba71ec573c44", + "type": "leaf", + "state": { + "type": "tag", + "state": { + "sortOrder": "frequency", + "useHierarchy": true, + "showSearch": false, + "searchQuery": "" + }, + "icon": "lucide-tags", + "title": "标签" + } + }, + { + "id": "a0a9b30669644b91", + "type": "leaf", + "state": { + "type": "all-properties", + "state": { + "sortOrder": "frequency", + "showSearch": false, + "searchQuery": "" + }, + "icon": "lucide-archive", + "title": "添加笔记属性" + } + }, + { + "id": "093bc224e527932e", + "type": "leaf", + "state": { + "type": "outline", + "state": { + "file": "部门五月份任务规划.md", + "followCursor": false, + "showSearch": false, + "searchQuery": "" + }, + "icon": "lucide-list", + "title": "部门五月份任务规划 的大纲" + } + }, + { + "id": "2076822cdefbb8a3", + "type": "leaf", + "state": { + "type": "git-view", + "state": {}, + "icon": "git-pull-request", + "title": "Source Control" + } + } + ], + "currentTab": 5 + } + ], + "direction": "horizontal", + "width": 300 + }, + "left-ribbon": { + "hiddenItems": { + "switcher:打开快速切换": false, + "graph:查看关系图谱": false, + "canvas:新建白板": false, + "daily-notes:打开/创建今天的日记": false, + "templates:插入模板": false, + "command-palette:打开命令面板": false, + "bases:新建数据库": false, + "obsidian-git:Open Git source control": false, + "pdf-plus:PDF++: Toggle auto-copy": false, + "pdf-plus:PDF++: Toggle auto-focus": false, + "pdf-plus:PDF++: Toggle auto-paste": false + } + }, + "active": "b0ba3684f585064f", + "lastOpenFiles": [] +} \ No newline at end of file