solomonkinard.git-blame

{
  "name": "git-blame",
  "displayName": "Git Blame",
  "description": "Every commit counts",
  "version": "0.2.127",
  "publisher": "solomonkinard",
  "icon": "media/icon.png",
  "repository": {
    "type": "git",
    "url": "https://github.com/solomonkinard/public"
  },
  "homepage": "https://gitblame.io",
  "badges": [
    {
      "url": "https://img.shields.io/badge/Supports-SSH-cornflowerblue",
      "href": "gitblame.io",
      "description": "Works over SSH / remote"
    }
  ],
  "engines": {
    "vscode": "^1.107.0"
  },
  "categories": [
    "SCM Providers"
  ],
  "activationEvents": [
    "onStartupFinished"
  ],
  "keywords": [
    "git lens"
  ],
  "capabilities": {
    "virtualWorkspaces": true,
    "untrustedWorkspaces": {
      "supported": "limited"
    }
  },
  "galleryBanner": {
    "color": "#4994EC",
    "theme": "dark"
  },
  "browser": "./dist/web/extension.js",
  "main": "./out/extension.js",
  "contributes": {
    "customEditors": [
      {
        "viewType": "git-blame.diffEditor",
        "displayName": "Diff Editor",
        "selector": [
          {
            "filenamePattern": "git-blame.diffEditor"
          }
        ]
      }
    ],
    "commands": [
      {
        "command": "git-blame.gitDiff.next",
        "title": ">"
      },
      {
        "command": "git-blame.gitDiff.prev",
        "title": "<"
      },
      {
        "command": "git-blame.commands.previousPatch",
        "title": "Git Blame: Time Machine",
        "icon": "$(repo-forked)"
      },
      {
        "command": "gitBlame.fileView.refresh",
        "title": "Refresh",
        "icon": "$(refresh)"
      },
      {
        "command": "git-blame.diffView.refresh",
        "title": "Refresh",
        "icon": "$(refresh)"
      },
      {
        "command": "git-blame.diffView.setRef",
        "title": "Base",
        "icon": "$(git-branch)"
      },
      {
        "command": "git-blame.diffView.setDir",
        "title": "Set directory",
        "icon": "$(folder)"
      },
      {
        "command": "git-blame.diffView.showFile",
        "title": "Show File",
        "icon": "$(preferences-open-settings)"
      },
      {
        "command": "git-blame.views.diff.revert",
        "title": "Revert",
        "icon": "$(discard)"
      },
      {
        "command": "git-blame.views.diff.commands.revertOthers",
        "title": "Revert others",
        "icon": "$(exclude)"
      },
      {
        "command": "gitBlame.lineView.refresh",
        "title": "Refresh",
        "icon": "$(refresh)"
      },
      {
        "command": "git-blame.OpenCommitOnTheWeb",
        "title": "Git Blame: Open Online",
        "icon": "$(browser)",
        "when": "editorIsOpen"
      },
      {
        "command": "git-blame.command.search",
        "title": "Git Blame: Search"
      },
      {
        "command": "git-blame.command.fileHistory",
        "title": "Git Blame: File History",
        "icon": "$(output)"
      },
      {
        "command": "git-blame.commands.showPatch",
        "title": "Git Blame: Show Patch"
      },
      {
        "command": "git-blame.logView.refresh",
        "title": "Refresh",
        "icon": "$(refresh)"
      },
      {
        "command": "git-blame.logView.setAuthor",
        "title": "Author",
        "icon": "$(person)"
      },
      {
        "command": "git-blame.logView.setRef",
        "title": "Ref",
        "icon": "$(repo-forked)"
      },
      {
        "command": "git-blame.logView.toggleReflog",
        "title": "Toggle reflog"
      },
      {
        "command": "git-blame.fileView.refresh",
        "title": "Refresh",
        "icon": "$(refresh)"
      },
      {
        "command": "git-blame.fileView.setAuthor",
        "title": "Author",
        "icon": "$(person)"
      },
      {
        "command": "git-blame.fileView.setRef",
        "title": "Ref",
        "icon": "$(repo-forked)"
      },
      {
        "command": "git-blame.fileView.toggleReflog",
        "title": "Toggle reflog"
      },
      {
        "command": "git-blame.diffView.diffAll",
        "title": "Diff All"
      },
      {
        "command": "git-blame.diffView.changes",
        "title": "Changes",
        "icon": "$(diff)"
      },
      {
        "command": "git-blame.branchView.refresh",
        "title": "Refresh",
        "icon": "$(refresh)"
      },
      {
        "command": "git-blame.branchView.base",
        "title": "Base",
        "icon": "$(repo-forked)"
      },
      {
        "command": "git-blame.branchView.checkout",
        "title": "Checkout",
        "icon": "$(pass)"
      },
      {
        "command": "git-blame.logView.amend",
        "title": "Amend",
        "icon": "$(pencil)"
      },
      {
        "command": "git-blame.treeView.openLog",
        "title": "Log",
        "icon": "$(list-tree)"
      },
      {
        "command": "git-blame.diffView.diffStat",
        "title": "Stat",
        "icon": "$(menu)"
      },
      {
        "command": "git-blame.treeView.openResourceUri",
        "title": "Open",
        "icon": "$(go-to-file)"
      },
      {
        "command": "git-blame.treeView.copyLabel",
        "title": "Copy",
        "icon": "$(files)"
      },
      {
        "command": "git-blame.treeView.copyDescription",
        "title": "Copy",
        "icon": "$(files)"
      },
      {
        "command": "git-blame.views.search.query",
        "title": "Query",
        "icon": "$(search)"
      },
      {
        "command": "git-blame.views.search.compareFiles",
        "title": "Compare files",
        "icon": "$(compare-changes)"
      },
      {
        "command": "git-blame.editorContext.log",
        "title": "Log"
      },
      {
        "command": "git-blame.editorContext.diff",
        "title": "Diff"
      },
      {
        "command": "git-blame.editorContext.patch",
        "title": "Patch"
      },
      {
        "command": "git-blame.editorContext.web",
        "title": "Web"
      },
      {
        "command": "git-blame.commands.editorContext.openFileOnline",
        "title": "Git Blame: Open file online",
        "icon": "$(globe)"
      },
      {
        "command": "git-blame.commands.commitDiffFile",
        "title": "Git Blame: Apply Diff File (from base)",
        "description": "Experimental and sometimes fails silently."
      },
      {
        "command": "git-blame.commands.showDiffFile",
        "title": "Git Blame: Show Diff File (from base)",
        "description": "Pre-requisite for commitDiffFile to show the diff from a base."
      },
      {
        "command": "git-blame.commands.quickPick.log",
        "title": "Git Blame: Git Log",
        "description": "Show the log in chunks, allowing for checkout, copy, and more."
      },
      {
        "command": "git-blame.commands.quickPick.reflog",
        "title": "Git Blame: Git Reflog",
        "description": "Show the reflog, similar to the related log command."
      },
      {
        "command": "git-blame.commands.quickPick.branch",
        "title": "Git Blame: Git Branch",
        "description": "Show branches in descending order from the most recent commit.",
        "icon": "$(menu)"
      },
      {
        "command": "git-blame.commands.setWordWrapOff",
        "title": "Git Blame: Set Word Wrap Off For Inline Blame",
        "description": "Inline blame works best when word wrap is off."
      },
      {
        "command": "git-blame.commands.tree.ref",
        "title": "Ref",
        "icon": "$(repo-forked)"
      },
      {
        "command": "git-blame.commands.tree.files",
        "title": "Files",
        "icon": "$(list-tree)"
      },
      {
        "command": "git-blame.commands.tree.up",
        "title": "Up",
        "icon": "$(arrow-up)"
      },
      {
        "command": "git-blame.commands.tree.activeEditor",
        "title": "Active editor location",
        "icon": "$(file)"
      },
      {
        "command": "git-blame.commands.interactiveSearch.menu",
        "title": "Git Blame: Interactive Search",
        "icon": "$(search-fuzzy)"
      },
      {
        "command": "git-blame.commands.stats",
        "title": "Git Blame: Stats"
      },
      {
        "command": "git-blame.commands.diffView.showInlineDiff",
        "title": "Git Blame: Show Inline Diff"
      },
      {
        "command": "git-blame.commands.openSettings",
        "title": "Git Blame: Show Settings"
      },
      {
        "command": "git-blame.views.line.commands.refresh",
        "title": "Refresh",
        "icon": "$(refresh)"
      },
      {
        "command": "git-blame.explorers.stash.commands.refresh",
        "title": "Refresh",
        "icon": "$(refresh)"
      },
      {
        "command": "git-blame.explorers.stash.commands.push",
        "title": "Push",
        "icon": "$(add)"
      },
      {
        "command": "git-blame.explorers.stash.commands.search",
        "title": "Search",
        "icon": "$(search)"
      },
      {
        "command": "git-blame.explorers.stash.commands.pop",
        "title": "Pop",
        "icon": "$(notebook-revert)"
      },
      {
        "command": "git-blame.explorers.stash.commands.apply",
        "title": "Apply",
        "icon": "$(repo-pull)"
      },
      {
        "command": "git-blame.explorers.stash.commands.drop",
        "title": "Drop",
        "icon": "$(trash)"
      },
      {
        "command": "git-blame.explorers.stash.commands.rename",
        "title": "Rename",
        "icon": "$(pencil)"
      },
      {
        "command": "git-blame.views.line.commands.export",
        "title": "Export",
        "icon": "$(export)"
      },
      {
        "command": "git-blame.views.line.commands.showQuickPick",
        "title": "Git Blame: Line History",
        "shortTitle": "Menu",
        "icon": "$(menu)"
      },
      {
        "command": "git-blame.views.line.commands.showLog",
        "title": "Log",
        "icon": "$(menu)"
      },
      {
        "command": "git-blame.changes.commands.showMenu",
        "title": "Git Blame: Files",
        "icon": "$(list-tree)"
      },
      {
        "command": "git-blame.library.commands.reportBug",
        "title": "Git Blame: Report Bug"
      },
      {
        "command": "git-blame.commands.inlineBlame.toggle",
        "title": "Git Blame: Toggle inline blame"
      },
      {
        "command": "git-blame.commands.commitHighlight.toggle",
        "title": "Git Blame: Toggle commit highlight"
      },
      {
        "command": "git-blame.commands.blame.computeTime",
        "title": "Git Blame: Compute Time"
      },
      {
        "command": "git-blame.commands.blame.toggleDiskCache",
        "title": "Git Blame: Toggle blame disk cache"
      },
      {
        "command": "git-blame.commands.scripts.menu",
        "title": "Git Blame: Scripts"
      },
      {
        "command": "git-blame.commands.checkpoints.menu",
        "title": "Git Blame: Checkpoints"
      },
      {
        "command": "git-blame.commands.cli.commit",
        "title": "Git Blame: Commit"
      }
    ],
    "configuration": {
      "title": "Git Blame",
      "properties": {
        "git-blame.gitWebUrl": {
          "type": "string",
          "default": "",
          "description": "Web url to open git log",
          "markdownDescription": "The url to open when opening git web online.\n\nExample: `https://example.com/$ID`, where `$ID` is the commit id."
        },
        "git-blame.config.showStatusBar": {
          "type": "boolean",
          "default": true,
          "description": "Status bar visibility."
        },
        "git-blame.config.logClickUrls": {
          "type": "object",
          "description": "Customizable click urls based the contents of a line."
        },
        "git-blame.config.showBlameInline": {
          "type": "boolean",
          "default": true,
          "description": "Show inline blame alongside code. Word wrapping must be disabled."
        },
        "git-blame.config.inlineBlameStartColumn": {
          "type": "number",
          "default": 80,
          "description": "What column to start the left aligned inline blame."
        },
        "git-blame.config.inlineBlameHoverMessage": {
          "type": "boolean",
          "default": false,
          "description": "Show inline blame hover text for all lines."
        },
        "git-blame.config.inlineBlame.hoverMessage.activeLine": {
          "type": "boolean",
          "default": true,
          "description": "Show inline blame hover text for the active line."
        },
        "git-blame.logView.maxCommitCount": {
          "type": "number",
          "default": 50,
          "description": "Maximum number of commits in Git Blame Log."
        },
        "git-blame.fileView.maxCommitCount": {
          "type": "number",
          "default": 50,
          "description": "Maximum number of commits in Git Blame File."
        },
        "git-blame.branchView.maxCommitCount": {
          "type": "number",
          "default": 50,
          "description": "Maximum number of commits in Git Blame Branch."
        },
        "git-blame.config.ignoreWhitespace": {
          "type": "boolean",
          "default": false,
          "description": "Ignore whitespace when tracing parent line origin."
        },
        "git-blame.configs.startBlameProcessOnSave": {
          "type": "boolean",
          "default": true,
          "description": "Start blame process on save?"
        },
        "git-blame.config.inlineBlame.position": {
          "type": "string",
          "default": "right",
          "enum": [
            "left",
            "right"
          ],
          "description": "On which side of the text to show the inline blame."
        },
        "git-blame.configs.statusBar.length": {
          "type": "string",
          "default": "medium",
          "enum": [
            "long",
            "medium",
            "short"
          ],
          "description": "Status bar length."
        },
        "git-blame.decoration.config.commitHighlight": {
          "type": "boolean",
          "default": true,
          "description": "Show decoration on all lines matching the commit on the active line."
        },
        "git-blame.decoration.config.commitHighlightColor": {
          "type": "string",
          "description": "Vertical bar highlight color for tick mark, e.g. #FFFFFF."
        },
        "git-blame.configurations.blame.diskCache": {
          "type": "boolean",
          "default": true,
          "description": "Use a file cache to speed up blame especially over ssh."
        }
      }
    },
    "submenus": [
      {
        "id": "git-blame.editorContext",
        "label": "Git Blame"
      }
    ],
    "menus": {
      "editor/title": [
        {
          "command": "git-blame.gitDiff.next",
          "group": "navigation@2",
          "when": "resourceScheme == git-blame.gitDiff"
        },
        {
          "command": "git-blame.gitDiff.prev",
          "group": "navigation@1",
          "when": "resourceScheme == git-blame.gitDiff"
        },
        {
          "command": "git-blame.commands.previousPatch",
          "group": "navigation@1"
        },
        {
          "command": "git-blame.changes.commands.showMenu",
          "group": "navigation@1",
          "when": "git-blame.changes.context.isMultiEditorOpen"
        }
      ],
      "editor/title/context": [
        {
          "group": "3_open",
          "submenu": "git-blame.editorContext"
        }
      ],
      "editor/context": [
        {
          "group": "1_close",
          "submenu": "git-blame.editorContext"
        }
      ],
      "git-blame.editorContext": [
        {
          "command": "git-blame.editorContext.log"
        },
        {
          "command": "git-blame.editorContext.web"
        },
        {
          "command": "git-blame.editorContext.diff"
        },
        {
          "command": "git-blame.editorContext.patch"
        }
      ],
      "commandPalette": [
        {
          "command": "git-blame.gitDiff.next",
          "when": "resourceScheme == git-blame.gitDiff"
        },
        {
          "command": "git-blame.gitDiff.prev",
          "when": "resourceScheme == git-blame.gitDiff"
        },
        {
          "command": "git-blame.views.line.commands.showQuickPick",
          "when": "editorIsOpen"
        },
        {
          "command": "git-blame.editorContext.log",
          "when": "editorIsOpen"
        },
        {
          "command": "git-blame.editorContext.diff",
          "when": "editorIsOpen"
        },
        {
          "command": "git-blame.editorContext.patch",
          "when": "editorIsOpen"
        },
        {
          "command": "git-blame.editorContext.web",
          "when": "editorIsOpen"
        },
        {
          "command": "git-blame.commands.editorContext.openFileOnline",
          "when": "editorIsOpen"
        },
        {
          "command": "git-blame.commands.commitDiffFile",
          "when": "editorIsOpen"
        },
        {
          "command": "git-blame.commands.showDiffFile",
          "when": "editorIsOpen"
        },
        {
          "command": "git-blame.commands.quickPick.log",
          "when": "editorIsOpen"
        },
        {
          "command": "git-blame.commands.quickPick.reflog",
          "when": "editorIsOpen"
        },
        {
          "command": "git-blame.commands.quickPick.branch",
          "when": "editorIsOpen"
        },
        {
          "command": "git-blame.commands.tree.ref",
          "when": "view == git-blame.explorers.explorer"
        },
        {
          "command": "git-blame.commands.tree.files",
          "when": "view == git-blame.explorers.explorer"
        },
        {
          "command": "git-blame.commands.tree.up",
          "when": "view == git-blame.explorers.explorer"
        },
        {
          "command": "git-blame.commands.tree.activeEditor",
          "when": "view == git-blame.explorers.explorer"
        },
        {
          "command": "git-blame.commands.stats",
          "when": "editorIsOpen"
        },
        {
          "command": "git-blame.commands.diffView.showInlineDiff",
          "when": "editorIsOpen"
        },
        {
          "command": "git-blame.changes.commands.showMenu",
          "when": "git-blame.changes.context.isMultiEditorOpen"
        },
        {
          "command": "git-blame.commands.inlineBlame.toggle",
          "when": "editorIsOpen"
        },
        {
          "command": "git-blame.commands.commitHighlight.toggle",
          "when": "editorIsOpen"
        },
        {
          "command": "git-blame.explorers.stash.commands.refresh",
          "when": "false"
        },
        {
          "command": "git-blame.explorers.stash.commands.push",
          "when": "false"
        },
        {
          "command": "git-blame.explorers.stash.commands.search",
          "when": "false"
        },
        {
          "command": "git-blame.explorers.stash.commands.pop",
          "when": "false"
        },
        {
          "command": "git-blame.explorers.stash.commands.apply",
          "when": "false"
        },
        {
          "command": "git-blame.explorers.stash.commands.drop",
          "when": "false"
        },
        {
          "command": "git-blame.explorers.stash.commands.rename",
          "when": "false"
        },
        {
          "command": "git-blame.views.diff.revert",
          "when": "false"
        },
        {
          "command": "git-blame.views.diff.commands.revertOthers",
          "when": "false"
        }
      ],
      "view/title": [
        {
          "command": "gitBlame.fileView.refresh",
          "when": "view == git-blame.views.file",
          "group": "navigation@2"
        },
        {
          "command": "git-blame.command.fileHistory",
          "when": "view == git-blame.views.file",
          "group": "navigation@1"
        },
        {
          "command": "git-blame.commands.editorContext.openFileOnline",
          "when": "view == git-blame.views.file",
          "group": "navigation@3"
        },
        {
          "command": "git-blame.diffView.diffStat",
          "when": "view == gitBlameDiffView",
          "group": "navigation"
        },
        {
          "command": "git-blame.diffView.setDir",
          "when": "view == gitBlameDiffView"
        },
        {
          "command": "git-blame.diffView.setRef",
          "when": "view == gitBlameDiffView",
          "group": "navigation"
        },
        {
          "command": "git-blame.diffView.refresh",
          "when": "view == gitBlameDiffView",
          "group": "navigation"
        },
        {
          "command": "git-blame.diffView.diffAll",
          "when": "view == gitBlameDiffView"
        },
        {
          "command": "git-blame.diffView.changes",
          "when": "view == gitBlameDiffView",
          "group": "navigation"
        },
        {
          "command": "git-blame.logView.refresh",
          "when": "view == gitBlameLogView",
          "group": "navigation"
        },
        {
          "command": "git-blame.logView.setAuthor",
          "when": "view == gitBlameLogView",
          "group": "navigation"
        },
        {
          "command": "git-blame.logView.setRef",
          "when": "view == gitBlameLogView",
          "group": "navigation"
        },
        {
          "command": "git-blame.logView.toggleReflog",
          "when": "view == gitBlameLogView"
        },
        {
          "command": "git-blame.views.line.commands.export",
          "when": "view == git-blame.views.line",
          "group": "navigation"
        },
        {
          "command": "git-blame.views.line.commands.showQuickPick",
          "when": "view == git-blame.views.line",
          "group": "navigation"
        },
        {
          "command": "git-blame.views.line.commands.refresh",
          "when": "view == git-blame.views.line",
          "group": "navigation"
        },
        {
          "command": "git-blame.fileView.refresh",
          "when": "view == gitBlameFileView",
          "group": "navigation"
        },
        {
          "command": "git-blame.fileView.setAuthor",
          "when": "view == gitBlameFileView",
          "group": "navigation"
        },
        {
          "command": "git-blame.fileView.setRef",
          "when": "view == gitBlameFileView",
          "group": "navigation"
        },
        {
          "command": "git-blame.fileView.toggleReflog",
          "when": "view == gitBlameFileView"
        },
        {
          "command": "git-blame.branchView.refresh",
          "when": "view == gitBlameBranchView",
          "group": "navigation"
        },
        {
          "command": "git-blame.branchView.base",
          "when": "view == gitBlameBranchView",
          "group": "navigation"
        },
        {
          "command": "git-blame.commands.quickPick.branch",
          "when": "view == gitBlameBranchView",
          "group": "navigation"
        },
        {
          "command": "git-blame.views.search.query",
          "when": "view == git-blame.views.search",
          "group": "navigation"
        },
        {
          "command": "git-blame.views.search.compareFiles",
          "when": "view == git-blame.views.search",
          "group": "navigation"
        },
        {
          "command": "git-blame.commands.interactiveSearch.menu",
          "when": "view == git-blame.views.search",
          "group": "navigation"
        },
        {
          "command": "git-blame.commands.tree.ref",
          "when": "view == git-blame.explorers.explorer",
          "group": "navigation@1"
        },
        {
          "command": "git-blame.commands.tree.files",
          "when": "view == git-blame.explorers.explorer",
          "group": "navigation@4"
        },
        {
          "command": "git-blame.commands.tree.up",
          "when": "view == git-blame.explorers.explorer",
          "group": "navigation@3"
        },
        {
          "command": "git-blame.commands.tree.activeEditor",
          "when": "view == git-blame.explorers.explorer && editorIsOpen",
          "group": "navigation@2"
        },
        {
          "command": "git-blame.explorers.stash.commands.refresh",
          "when": "editorIsOpen && view == git-blame.explorers.stash",
          "group": "navigation@1"
        },
        {
          "command": "git-blame.explorers.stash.commands.push",
          "when": "editorIsOpen && view == git-blame.explorers.stash",
          "group": "navigation@3"
        },
        {
          "command": "git-blame.explorers.stash.commands.search",
          "when": "editorIsOpen && view == git-blame.explorers.stash",
          "group": "navigation@2"
        }
      ],
      "view/item/context": [
        {
          "command": "git-blame.diffView.showFile",
          "when": "view == gitBlameDiffView",
          "group": "inline@3"
        },
        {
          "command": "git-blame.views.diff.revert",
          "when": "view == gitBlameDiffView",
          "group": "inline@2"
        },
        {
          "command": "git-blame.views.diff.commands.revertOthers",
          "when": "view == gitBlameDiffView",
          "group": "inline@1"
        },
        {
          "command": "git-blame.treeView.openLog",
          "when": "view == gitBlameLogView && viewItem == commit",
          "group": "inline"
        },
        {
          "command": "git-blame.treeView.openResourceUri",
          "when": "view == gitBlameLogView && viewItem == file",
          "group": "inline"
        },
        {
          "command": "git-blame.treeView.openResourceUri",
          "when": "view == gitBlameFileView && viewItem == file",
          "group": "inline"
        },
        {
          "command": "git-blame.treeView.openLog",
          "when": "view == gitBlameFileView && viewItem == commit",
          "group": "inline"
        },
        {
          "command": "git-blame.treeView.openResourceUri",
          "when": "view == gitBlameBranchView && viewItem == file",
          "group": "inline"
        },
        {
          "command": "git-blame.treeView.openLog",
          "when": "view == gitBlameBranchView && viewItem == branch",
          "group": "inline"
        },
        {
          "command": "git-blame.branchView.checkout",
          "when": "view == gitBlameBranchView && viewItem == branch"
        },
        {
          "command": "git-blame.logView.amend",
          "when": "view == gitBlameLogView && viewItem == commit",
          "group": "inline"
        },
        {
          "command": "git-blame.treeView.openLog",
          "when": "view == git-blame.views.file && viewItem == commit",
          "group": "inline"
        },
        {
          "command": "git-blame.treeView.copyLabel",
          "when": "view == gitBlameBranchView && viewItem == branch",
          "group": "inline"
        },
        {
          "command": "git-blame.treeView.openLog",
          "when": "view == git-blame.views.search && viewItem == commit",
          "group": "inline"
        },
        {
          "command": "git-blame.treeView.openResourceUri",
          "when": "view == git-blame.views.search && viewItem == file",
          "group": "inline"
        },
        {
          "command": "git-blame.explorers.stash.commands.pop",
          "when": "view == git-blame.explorers.stash",
          "group": "inline@2"
        },
        {
          "command": "git-blame.explorers.stash.commands.drop",
          "when": "view == git-blame.explorers.stash",
          "group": "inline@3"
        },
        {
          "command": "git-blame.explorers.stash.commands.apply",
          "when": "view == git-blame.explorers.stash",
          "group": "inline@2"
        },
        {
          "command": "git-blame.explorers.stash.commands.rename",
          "when": "view == git-blame.explorers.stash",
          "group": "inline@1"
        }
      ]
    },
    "viewsContainers": {
      "activitybar": [
        {
          "id": "git-blame-explorer",
          "title": "Git Blame",
          "icon": "media/activity_bar.svg"
        }
      ]
    },
    "views": {
      "git-blame-explorer": [
        {
          "id": "gitBlameDiffView",
          "name": "Diff",
          "when": "editorIsOpen",
          "description": "Interactive diff. Command click to navigate to specific lines."
        },
        {
          "id": "git-blame.views.line",
          "name": "Line",
          "when": "editorIsOpen",
          "description": "Load the line history asynchronously in the menu."
        },
        {
          "id": "gitBlameBranchView",
          "name": "Branch",
          "when": "editorIsOpen",
          "description": "Show available branches."
        },
        {
          "id": "gitBlameLogView",
          "name": "Log",
          "when": "editorIsOpen",
          "description": "Show the log up to a certain predefined amount, which could be larger."
        },
        {
          "id": "git-blame.views.file",
          "name": "File",
          "when": "editorIsOpen",
          "description": "Show the file history while also considering renames and moves."
        },
        {
          "id": "git-blame.views.search",
          "name": "Search",
          "when": "editorIsOpen",
          "description": "Search the repository directly from the IDE."
        },
        {
          "id": "git-blame.explorers.explorer",
          "name": "Explorer",
          "when": "editorIsOpen",
          "description": "Explore the entire folder structure of a different branch or older sha."
        },
        {
          "id": "git-blame.explorers.stash",
          "name": "Stash",
          "when": "editorIsOpen",
          "description": "Git stash."
        }
      ]
    }
  },
  "sha": "b9e21f0fd90ced7ca196d37e3b6f0ece5207b807"
}

"use strict";
var L = Object.defineProperty;
var pr = Object.getOwnPropertyDescriptor;
var sr = Object.getOwnPropertyNames;
var wr = Object.prototype.hasOwnProperty;
var xr = (i, r) =>
  {
    for (var n in r) L(i, n,
    {
      get: r[n],
      enumerable: !0
    })
  },
  Er = (i, r, n, e) =>
  {
    if (r && typeof r == "object" || typeof r == "function")
      for (let t of sr(r)) !wr.call(i, t) && t !== n && L(i, t,
      {
        get: () => r[t],
        enumerable: !(e = pr(r, t)) || e.enumerable
      });
    return i
  };
var mr = i => Er(L(
{}, "__esModule",
{
  value: !0
}), i);
var Rn = {};
xr(Rn,
{
  activate: () => Tn
});
module.exports = mr(Rn);

function J()
{
  throw new Error("setTimeout has not been defined")
}

function O()
{
  throw new Error("clearTimeout has not been defined")
}
var R = J,
  _ = O;
typeof globalThis.setTimeout == "function" && (R = setTimeout);
typeof globalThis.clearTimeout == "function" && (_ = clearTimeout);

function Q(i)
{
  if (R === setTimeout) return setTimeout(i, 0);
  if ((R === J || !R) && setTimeout) return R = setTimeout, setTimeout(i, 0);
  try
  {
    return R(i, 0)
  }
  catch
  {
    try
    {
      return R.call(null, i, 0)
    }
    catch
    {
      return R.call(this, i, 0)
    }
  }
}

function Ar(i)
{
  if (_ === clearTimeout) return clearTimeout(i);
  if ((_ === O || !_) && clearTimeout) return _ = clearTimeout, clearTimeout(i);
  try
  {
    return _(i)
  }
  catch
  {
    try
    {
      return _.call(null, i)
    }
    catch
    {
      return _.call(this, i)
    }
  }
}
var y = [],
  Y = !1,
  v, S = -1;

function gr()
{
  !Y || !v || (Y = !1, v.length ? y = v.concat(y) : S = -1, y.length && X())
}

function X()
{
  if (!Y)
  {
    var i = Q(gr);
    Y = !0;
    for (var r = y.length; r;)
    {
      for (v = y, y = []; ++S < r;) v && v[S].run();
      S = -1, r = y.length
    }
    v = null, Y = !1, Ar(i)
  }
}

function yr(i)
{
  var r = new Array(arguments.length - 1);
  if (arguments.length > 1)
    for (var n = 1; n < arguments.length; n++) r[n - 1] = arguments[n];
  y.push(new q(i, r)), y.length === 1 && !Y && Q(X)
}

function q(i, r)
{
  this.fun = i, this.array = r
}
q.prototype.run = function ()
{
  this.fun.apply(null, this.array)
};
var Tr = "browser",
  Rr = "browser",
  _r = !0,
  vr = {},
  Ir = [],
  Ur = "",
  Br = {},
  dr = {},
  Yr = {};

function I()
{}
var Sr = I,
  Pr = I,
  Mr = I,
  Dr = I,
  Cr = I,
  kr = I,
  Nr = I;

function Lr(i)
{
  throw new Error("process.binding is not supported")
}

function Fr()
{
  return "/"
}

function Wr(i)
{
  throw new Error("process.chdir is not supported")
}

function Hr()
{
  return 0
}
var d = globalThis.performance ||
  {},
  Vr = d.now || d.mozNow || d.msNow || d.oNow || d.webkitNow || function ()
  {
    return new Date().getTime()
  };

function zr(i)
{
  var r = Vr.call(d) * .001,
    n = Math.floor(r),
    e = Math.floor(r % 1 * 1e9);
  return i && (n = n - i[0], e = e - i[1], e < 0 && (n--, e += 1e9)), [n, e]
}
var Gr = new Date;

function Jr()
{
  var i = new Date,
    r = i - Gr;
  return r / 1e3
}
var F = {
    nextTick: yr,
    title: Tr,
    browser: _r,
    env: vr,
    argv: Ir,
    version: Ur,
    versions: Br,
    on: Sr,
    addListener: Pr,
    once: Mr,
    off: Dr,
    removeListener: Cr,
    removeAllListeners: kr,
    emit: Nr,
    binding: Lr,
    cwd: Fr,
    chdir: Wr,
    umask: Hr,
    hrtime: zr,
    platform: Rr,
    release: dr,
    config: Yr,
    uptime: Jr
  },
  G = {};
Object.keys(G).forEach(i =>
{
  let r = i.split("."),
    n = F;
  for (let e = 0; e < r.length; e++)
  {
    let t = r[e];
    e === r.length - 1 ? n[t] = G[i] : n = n[t] || (n[t] = {})
  }
});
var A = [],
  E = [],
  Or = typeof Uint8Array < "u" ? Uint8Array : Array,
  H = !1;

function b()
{
  H = !0;
  for (var i = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", r = 0, n = i.length; r < n; ++r) A[r] = i[r], E[i.charCodeAt(r)] = r;
  E[45] = 62, E[95] = 63
}

function Qr(i)
{
  H || b();
  var r, n, e, t, f, u, a = i.length;
  if (a % 4 > 0) throw new Error("Invalid string. Length must be a multiple of 4");
  f = i[a - 2] === "=" ? 2 : i[a - 1] === "=" ? 1 : 0, u = new Or(a * 3 / 4 - f), e = f > 0 ? a - 4 : a;
  var h = 0;
  for (r = 0, n = 0; r < e; r += 4, n += 3) t = E[i.charCodeAt(r)] << 18 | E[i.charCodeAt(r + 1)] << 12 | E[i.charCodeAt(r + 2)] << 6 | E[i.charCodeAt(r + 3)], u[h++] = t >> 16 & 255, u[h++] = t >> 8 & 255, u[h++] = t & 255;
  return f === 2 ? (t = E[i.charCodeAt(r)] << 2 | E[i.charCodeAt(r + 1)] >> 4, u[h++] = t & 255) : f === 1 && (t = E[i.charCodeAt(r)] << 10 | E[i.charCodeAt(r + 1)] << 4 | E[i.charCodeAt(r + 2)] >> 2, u[h++] = t >> 8 & 255, u[h++] = t & 255), u
}

function Xr(i)
{
  return A[i >> 18 & 63] + A[i >> 12 & 63] + A[i >> 6 & 63] + A[i & 63]
}

function qr(i, r, n)
{
  for (var e, t = [], f = r; f < n; f += 3) e = (i[f] << 16) + (i[f + 1] << 8) + i[f + 2], t.push(Xr(e));
  return t.join("")
}

function Z(i)
{
  H || b();
  for (var r, n = i.length, e = n % 3, t = "", f = [], u = 16383, a = 0, h = n - e; a < h; a += u) f.push(qr(i, a, a + u > h ? h : a + u));
  return e === 1 ? (r = i[n - 1], t += A[r >> 2], t += A[r << 4 & 63], t += "==") : e === 2 && (r = (i[n - 2] << 8) + i[n - 1], t += A[r >> 10], t += A[r >> 4 & 63], t += A[r << 2 & 63], t += "="), f.push(t), f.join("")
}
o.TYPED_ARRAY_SUPPORT = globalThis.TYPED_ARRAY_SUPPORT !== void 0 ? globalThis.TYPED_ARRAY_SUPPORT : !0;

function P()
{
  return o.TYPED_ARRAY_SUPPORT ? 2147483647 : 1073741823
}

function T(i, r)
{
  if (P() < r) throw new RangeError("Invalid typed array length");
  return o.TYPED_ARRAY_SUPPORT ? (i = new Uint8Array(r), i.__proto__ = o.prototype) : (i === null && (i = new o(r)), i.length = r), i
}

function o(i, r, n)
{
  if (!o.TYPED_ARRAY_SUPPORT && !(this instanceof o)) return new o(i, r, n);
  if (typeof i == "number")
  {
    if (typeof r == "string") throw new Error("If encoding is specified then the first argument must be a string");
    return V(this, i)
  }
  return j(this, i, r, n)
}
o.poolSize = 8192;
o._augment = function (i)
{
  return i.__proto__ = o.prototype, i
};

function j(i, r, n, e)
{
  if (typeof r == "number") throw new TypeError('"value" argument must not be a number');
  return typeof ArrayBuffer < "u" && r instanceof ArrayBuffer ? $r(i, r, n, e) : typeof r == "string" ? Kr(i, r, n) : br(i, r)
}
o.from = function (i, r, n)
{
  return j(null, i, r, n)
};
o.kMaxLength = P();
o.TYPED_ARRAY_SUPPORT && (o.prototype.__proto__ = Uint8Array.prototype, o.__proto__ = Uint8Array, typeof Symbol < "u" && Symbol.species && o[Symbol.species]);

function rr(i)
{
  if (typeof i != "number") throw new TypeError('"size" argument must be a number');
  if (i < 0) throw new RangeError('"size" argument must not be negative')
}

function Zr(i, r, n, e)
{
  return rr(r), r <= 0 ? T(i, r) : n !== void 0 ? typeof e == "string" ? T(i, r).fill(n, e) : T(i, r).fill(n) : T(i, r)
}
o.alloc = function (i, r, n)
{
  return Zr(null, i, r, n)
};

function V(i, r)
{
  if (rr(r), i = T(i, r < 0 ? 0 : z(r) | 0), !o.TYPED_ARRAY_SUPPORT)
    for (var n = 0; n < r; ++n) i[n] = 0;
  return i
}
o.allocUnsafe = function (i)
{
  return V(null, i)
};
o.allocUnsafeSlow = function (i)
{
  return V(null, i)
};

function Kr(i, r, n)
{
  if ((typeof n != "string" || n === "") && (n = "utf8"), !o.isEncoding(n)) throw new TypeError('"encoding" must be a valid string encoding');
  var e = nr(r, n) | 0;
  i = T(i, e);
  var t = i.write(r, n);
  return t !== e && (i = i.slice(0, t)), i
}

function W(i, r)
{
  var n = r.length < 0 ? 0 : z(r.length) | 0;
  i = T(i, n);
  for (var e = 0; e < n; e += 1) i[e] = r[e] & 255;
  return i
}

function $r(i, r, n, e)
{
  if (r.byteLength, n < 0 || r.byteLength < n) throw new RangeError("'offset' is out of bounds");
  if (r.byteLength < n + (e || 0)) throw new RangeError("'length' is out of bounds");
  return n === void 0 && e === void 0 ? r = new Uint8Array(r) : e === void 0 ? r = new Uint8Array(r, n) : r = new Uint8Array(r, n, e), o.TYPED_ARRAY_SUPPORT ? (i = r, i.__proto__ = o.prototype) : i = W(i, r), i
}

function br(i, r)
{
  if (g(r))
  {
    var n = z(r.length) | 0;
    return i = T(i, n), i.length === 0 || r.copy(i, 0, 0, n), i
  }
  if (r)
  {
    if (typeof ArrayBuffer < "u" && r.buffer instanceof ArrayBuffer || "length" in r) return typeof r.length != "number" || An(r.length) ? T(i, 0) : W(i, r);
    if (r.type === "Buffer" && Array.isArray(r.data)) return W(i, r.data)
  }
  throw new TypeError("First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.")
}

function z(i)
{
  if (i >= P()) throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + P().toString(16) + " bytes");
  return i | 0
}
o.isBuffer = gn;

function g(i)
{
  return !!(i != null && i._isBuffer)
}
o.compare = function (r, n)
{
  if (!g(r) || !g(n)) throw new TypeError("Arguments must be Buffers");
  if (r === n) return 0;
  for (var e = r.length, t = n.length, f = 0, u = Math.min(e, t); f < u; ++f)
    if (r[f] !== n[f])
    {
      e = r[f], t = n[f];
      break
    } return e < t ? -1 : t < e ? 1 : 0
};
o.isEncoding = function (r)
{
  switch (String(r).toLowerCase())
  {
  case "hex":
  case "utf8":
  case "utf-8":
  case "ascii":
  case "latin1":
  case "binary":
  case "base64":
  case "ucs2":
  case "ucs-2":
  case "utf16le":
  case "utf-16le":
    return !0;
  default:
    return !1
  }
};
o.concat = function (r, n)
{
  if (!Array.isArray(r)) throw new TypeError('"list" argument must be an Array of Buffers');
  if (r.length === 0) return o.alloc(0);
  var e;
  if (n === void 0)
    for (n = 0, e = 0; e < r.length; ++e) n += r[e].length;
  var t = o.allocUnsafe(n),
    f = 0;
  for (e = 0; e < r.length; ++e)
  {
    var u = r[e];
    if (!g(u)) throw new TypeError('"list" argument must be an Array of Buffers');
    u.copy(t, f), f += u.length
  }
  return t
};

function nr(i, r)
{
  if (g(i)) return i.length;
  if (typeof ArrayBuffer < "u" && typeof ArrayBuffer.isView == "function" && (ArrayBuffer.isView(i) || i instanceof ArrayBuffer)) return i.byteLength;
  typeof i != "string" && (i = "" + i);
  var n = i.length;
  if (n === 0) return 0;
  for (var e = !1;;) switch (r)
  {
  case "ascii":
  case "latin1":
  case "binary":
    return n;
  case "utf8":
  case "utf-8":
  case void 0:
    return M(i).length;
  case "ucs2":
  case "ucs-2":
  case "utf16le":
  case "utf-16le":
    return n * 2;
  case "hex":
    return n >>> 1;
  case "base64":
    return ar(i).length;
  default:
    if (e) return M(i).length;
    r = ("" + r).toLowerCase(), e = !0
  }
}
o.byteLength = nr;

function jr(i, r, n)
{
  var e = !1;
  if ((r === void 0 || r < 0) && (r = 0), r > this.length || ((n === void 0 || n > this.length) && (n = this.length), n <= 0) || (n >>>= 0, r >>>= 0, n <= r)) return "";
  for (i || (i = "utf8");;) switch (i)
  {
  case "hex":
    return cn(this, r, n);
  case "utf8":
  case "utf-8":
    return tr(this, r, n);
  case "ascii":
    return an(this, r, n);
  case "latin1":
  case "binary":
    return hn(this, r, n);
  case "base64":
    return un(this, r, n);
  case "ucs2":
  case "ucs-2":
  case "utf16le":
  case "utf-16le":
    return ln(this, r, n);
  default:
    if (e) throw new TypeError("Unknown encoding: " + i);
    i = (i + "").toLowerCase(), e = !0
  }
}
o.prototype._isBuffer = !0;

function U(i, r, n)
{
  var e = i[r];
  i[r] = i[n], i[n] = e
}
o.prototype.swap16 = function ()
{
  var r = this.length;
  if (r % 2 !== 0) throw new RangeError("Buffer size must be a multiple of 16-bits");
  for (var n = 0; n < r; n += 2) U(this, n, n + 1);
  return this
};
o.prototype.swap32 = function ()
{
  var r = this.length;
  if (r % 4 !== 0) throw new RangeError("Buffer size must be a multiple of 32-bits");
  for (var n = 0; n < r; n += 4) U(this, n, n + 3), U(this, n + 1, n + 2);
  return this
};
o.prototype.swap64 = function ()
{
  var r = this.length;
  if (r % 8 !== 0) throw new RangeError("Buffer size must be a multiple of 64-bits");
  for (var n = 0; n < r; n += 8) U(this, n, n + 7), U(this, n + 1, n + 6), U(this, n + 2, n + 5), U(this, n + 3, n + 4);
  return this
};
o.prototype.toString = function ()
{
  var r = this.length | 0;
  return r === 0 ? "" : arguments.length === 0 ? tr(this, 0, r) : jr.apply(this, arguments)
};
o.prototype.equals = function (r)
{
  if (!g(r)) throw new TypeError("Argument must be a Buffer");
  return this === r ? !0 : o.compare(this, r) === 0
};
o.prototype.compare = function (r, n, e, t, f)
{
  if (!g(r)) throw new TypeError("Argument must be a Buffer");
  if (n === void 0 && (n = 0), e === void 0 && (e = r ? r.length : 0), t === void 0 && (t = 0), f === void 0 && (f = this.length), n < 0 || e > r.length || t < 0 || f > this.length) throw new RangeError("out of range index");
  if (t >= f && n >= e) return 0;
  if (t >= f) return -1;
  if (n >= e) return 1;
  if (n >>>= 0, e >>>= 0, t >>>= 0, f >>>= 0, this === r) return 0;
  for (var u = f - t, a = e - n, h = Math.min(u, a), l = this.slice(t, f), p = r.slice(n, e), c = 0; c < h; ++c)
    if (l[c] !== p[c])
    {
      u = l[c], a = p[c];
      break
    } return u < a ? -1 : a < u ? 1 : 0
};

function ir(i, r, n, e, t)
{
  if (i.length === 0) return -1;
  if (typeof n == "string" ? (e = n, n = 0) : n > 2147483647 ? n = 2147483647 : n < -2147483648 && (n = -2147483648), n = +n, isNaN(n) && (n = t ? 0 : i.length - 1), n < 0 && (n = i.length + n), n >= i.length)
  {
    if (t) return -1;
    n = i.length - 1
  }
  else if (n < 0)
    if (t) n = 0;
    else return -1;
  if (typeof r == "string" && (r = o.from(r, e)), g(r)) return r.length === 0 ? -1 : K(i, r, n, e, t);
  if (typeof r == "number") return r = r & 255, o.TYPED_ARRAY_SUPPORT && typeof Uint8Array.prototype.indexOf == "function" ? t ? Uint8Array.prototype.indexOf.call(i, r, n) : Uint8Array.prototype.lastIndexOf.call(i, r, n) : K(i, [r], n, e, t);
  throw new TypeError("val must be string, number or Buffer")
}

function K(i, r, n, e, t)
{
  var f = 1,
    u = i.length,
    a = r.length;
  if (e !== void 0 && (e = String(e).toLowerCase(), e === "ucs2" || e === "ucs-2" || e === "utf16le" || e === "utf-16le"))
  {
    if (i.length < 2 || r.length < 2) return -1;
    f = 2, u /= 2, a /= 2, n /= 2
  }

  function h(x, B)
  {
    return f === 1 ? x[B] : x.readUInt16BE(B * f)
  }
  var l;
  if (t)
  {
    var p = -1;
    for (l = n; l < u; l++)
      if (h(i, l) === h(r, p === -1 ? 0 : l - p))
      {
        if (p === -1 && (p = l), l - p + 1 === a) return p * f
      }
    else p !== -1 && (l -= l - p), p = -1
  }
  else
    for (n + a > u && (n = u - a), l = n; l >= 0; l--)
    {
      for (var c = !0, m = 0; m < a; m++)
        if (h(i, l + m) !== h(r, m))
        {
          c = !1;
          break
        } if (c) return l
    }
  return -1
}
o.prototype.includes = function (r, n, e)
{
  return this.indexOf(r, n, e) !== -1
};
o.prototype.indexOf = function (r, n, e)
{
  return ir(this, r, n, e, !0)
};
o.prototype.lastIndexOf = function (r, n, e)
{
  return ir(this, r, n, e, !1)
};

function rn(i, r, n, e)
{
  n = Number(n) || 0;
  var t = i.length - n;
  e ? (e = Number(e), e > t && (e = t)) : e = t;
  var f = r.length;
  if (f % 2 !== 0) throw new TypeError("Invalid hex string");
  e > f / 2 && (e = f / 2);
  for (var u = 0; u < e; ++u)
  {
    var a = parseInt(r.substr(u * 2, 2), 16);
    if (isNaN(a)) return u;
    i[n + u] = a
  }
  return u
}

function nn(i, r, n, e)
{
  return k(M(r, i.length - n), i, n, e)
}

function er(i, r, n, e)
{
  return k(En(r), i, n, e)
}

function en(i, r, n, e)
{
  return er(i, r, n, e)
}

function tn(i, r, n, e)
{
  return k(ar(r), i, n, e)
}

function fn(i, r, n, e)
{
  return k(mn(r, i.length - n), i, n, e)
}
o.prototype.write = function (r, n, e, t)
{
  if (n === void 0) t = "utf8", e = this.length, n = 0;
  else if (e === void 0 && typeof n == "string") t = n, e = this.length, n = 0;
  else if (isFinite(n)) n = n | 0, isFinite(e) ? (e = e | 0, t === void 0 && (t = "utf8")) : (t = e, e = void 0);
  else throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
  var f = this.length - n;
  if ((e === void 0 || e > f) && (e = f), r.length > 0 && (e < 0 || n < 0) || n > this.length) throw new RangeError("Attempt to write outside buffer bounds");
  t || (t = "utf8");
  for (var u = !1;;) switch (t)
  {
  case "hex":
    return rn(this, r, n, e);
  case "utf8":
  case "utf-8":
    return nn(this, r, n, e);
  case "ascii":
    return er(this, r, n, e);
  case "latin1":
  case "binary":
    return en(this, r, n, e);
  case "base64":
    return tn(this, r, n, e);
  case "ucs2":
  case "ucs-2":
  case "utf16le":
  case "utf-16le":
    return fn(this, r, n, e);
  default:
    if (u) throw new TypeError("Unknown encoding: " + t);
    t = ("" + t).toLowerCase(), u = !0
  }
};
o.prototype.toJSON = function ()
{
  return {
    type: "Buffer",
    data: Array.prototype.slice.call(this._arr || this, 0)
  }
};

function un(i, r, n)
{
  return r === 0 && n === i.length ? Z(i) : Z(i.slice(r, n))
}

function tr(i, r, n)
{
  n = Math.min(i.length, n);
  for (var e = [], t = r; t < n;)
  {
    var f = i[t],
      u = null,
      a = f > 239 ? 4 : f > 223 ? 3 : f > 191 ? 2 : 1;
    if (t + a <= n)
    {
      var h, l, p, c;
      switch (a)
      {
      case 1:
        f < 128 && (u = f);
        break;
      case 2:
        h = i[t + 1], (h & 192) === 128 && (c = (f & 31) << 6 | h & 63, c > 127 && (u = c));
        break;
      case 3:
        h = i[t + 1], l = i[t + 2], (h & 192) === 128 && (l & 192) === 128 && (c = (f & 15) << 12 | (h & 63) << 6 | l & 63, c > 2047 && (c < 55296 || c > 57343) && (u = c));
        break;
      case 4:
        h = i[t + 1], l = i[t + 2], p = i[t + 3], (h & 192) === 128 && (l & 192) === 128 && (p & 192) === 128 && (c = (f & 15) << 18 | (h & 63) << 12 | (l & 63) << 6 | p & 63, c > 65535 && c < 1114112 && (u = c))
      }
    }
    u === null ? (u = 65533, a = 1) : u > 65535 && (u -= 65536, e.push(u >>> 10 & 1023 | 55296), u = 56320 | u & 1023), e.push(u), t += a
  }
  return on(e)
}
var $ = 4096;

function on(i)
{
  var r = i.length;
  if (r <= $) return String.fromCharCode.apply(String, i);
  for (var n = "", e = 0; e < r;) n += String.fromCharCode.apply(String, i.slice(e, e += $));
  return n
}

function an(i, r, n)
{
  var e = "";
  n = Math.min(i.length, n);
  for (var t = r; t < n; ++t) e += String.fromCharCode(i[t] & 127);
  return e
}

function hn(i, r, n)
{
  var e = "";
  n = Math.min(i.length, n);
  for (var t = r; t < n; ++t) e += String.fromCharCode(i[t]);
  return e
}

function cn(i, r, n)
{
  var e = i.length;
  (!r || r < 0) && (r = 0), (!n || n < 0 || n > e) && (n = e);
  for (var t = "", f = r; f < n; ++f) t += xn(i[f]);
  return t
}

function ln(i, r, n)
{
  for (var e = i.slice(r, n), t = "", f = 0; f < e.length; f += 2) t += String.fromCharCode(e[f] + e[f + 1] * 256);
  return t
}
o.prototype.slice = function (r, n)
{
  var e = this.length;
  r = ~~r, n = n === void 0 ? e : ~~n, r < 0 ? (r += e, r < 0 && (r = 0)) : r > e && (r = e), n < 0 ? (n += e, n < 0 && (n = 0)) : n > e && (n = e), n < r && (n = r);
  var t;
  if (o.TYPED_ARRAY_SUPPORT) t = this.subarray(r, n), t.__proto__ = o.prototype;
  else
  {
    var f = n - r;
    t = new o(f, void 0);
    for (var u = 0; u < f; ++u) t[u] = this[u + r]
  }
  return t
};

function s(i, r, n)
{
  if (i % 1 !== 0 || i < 0) throw new RangeError("offset is not uint");
  if (i + r > n) throw new RangeError("Trying to access beyond buffer length")
}
o.prototype.readUIntLE = function (r, n, e)
{
  r = r | 0, n = n | 0, e || s(r, n, this.length);
  for (var t = this[r], f = 1, u = 0; ++u < n && (f *= 256);) t += this[r + u] * f;
  return t
};
o.prototype.readUIntBE = function (r, n, e)
{
  r = r | 0, n = n | 0, e || s(r, n, this.length);
  for (var t = this[r + --n], f = 1; n > 0 && (f *= 256);) t += this[r + --n] * f;
  return t
};
o.prototype.readUInt8 = function (r, n)
{
  return n || s(r, 1, this.length), this[r]
};
o.prototype.readUInt16LE = function (r, n)
{
  return n || s(r, 2, this.length), this[r] | this[r + 1] << 8
};
o.prototype.readUInt16BE = function (r, n)
{
  return n || s(r, 2, this.length), this[r] << 8 | this[r + 1]
};
o.prototype.readUInt32LE = function (r, n)
{
  return n || s(r, 4, this.length), (this[r] | this[r + 1] << 8 | this[r + 2] << 16) + this[r + 3] * 16777216
};
o.prototype.readUInt32BE = function (r, n)
{
  return n || s(r, 4, this.length), this[r] * 16777216 + (this[r + 1] << 16 | this[r + 2] << 8 | this[r + 3])
};
o.prototype.readIntLE = function (r, n, e)
{
  r = r | 0, n = n | 0, e || s(r, n, this.length);
  for (var t = this[r], f = 1, u = 0; ++u < n && (f *= 256);) t += this[r + u] * f;
  return f *= 128, t >= f && (t -= Math.pow(2, 8 * n)), t
};
o.prototype.readIntBE = function (r, n, e)
{
  r = r | 0, n = n | 0, e || s(r, n, this.length);
  for (var t = n, f = 1, u = this[r + --t]; t > 0 && (f *= 256);) u += this[r + --t] * f;
  return f *= 128, u >= f && (u -= Math.pow(2, 8 * n)), u
};
o.prototype.readInt8 = function (r, n)
{
  return n || s(r, 1, this.length), this[r] & 128 ? (255 - this[r] + 1) * -1 : this[r]
};
o.prototype.readInt16LE = function (r, n)
{
  n || s(r, 2, this.length);
  var e = this[r] | this[r + 1] << 8;
  return e & 32768 ? e | 4294901760 : e
};
o.prototype.readInt16BE = function (r, n)
{
  n || s(r, 2, this.length);
  var e = this[r + 1] | this[r] << 8;
  return e & 32768 ? e | 4294901760 : e
};
o.prototype.readInt32LE = function (r, n)
{
  return n || s(r, 4, this.length), this[r] | this[r + 1] << 8 | this[r + 2] << 16 | this[r + 3] << 24
};
o.prototype.readInt32BE = function (r, n)
{
  return n || s(r, 4, this.length), this[r] << 24 | this[r + 1] << 16 | this[r + 2] << 8 | this[r + 3]
};
o.prototype.readFloatLE = function (r, n)
{
  return n || s(r, 4, this.length), N(this, r, !0, 23, 4)
};
o.prototype.readFloatBE = function (r, n)
{
  return n || s(r, 4, this.length), N(this, r, !1, 23, 4)
};
o.prototype.readDoubleLE = function (r, n)
{
  return n || s(r, 8, this.length), N(this, r, !0, 52, 8)
};
o.prototype.readDoubleBE = function (r, n)
{
  return n || s(r, 8, this.length), N(this, r, !1, 52, 8)
};

function w(i, r, n, e, t, f)
{
  if (!g(i)) throw new TypeError('"buffer" argument must be a Buffer instance');
  if (r > t || r < f) throw new RangeError('"value" argument is out of bounds');
  if (n + e > i.length) throw new RangeError("Index out of range")
}
o.prototype.writeUIntLE = function (r, n, e, t)
{
  if (r = +r, n = n | 0, e = e | 0, !t)
  {
    var f = Math.pow(2, 8 * e) - 1;
    w(this, r, n, e, f, 0)
  }
  var u = 1,
    a = 0;
  for (this[n] = r & 255; ++a < e && (u *= 256);) this[n + a] = r / u & 255;
  return n + e
};
o.prototype.writeUIntBE = function (r, n, e, t)
{
  if (r = +r, n = n | 0, e = e | 0, !t)
  {
    var f = Math.pow(2, 8 * e) - 1;
    w(this, r, n, e, f, 0)
  }
  var u = e - 1,
    a = 1;
  for (this[n + u] = r & 255; --u >= 0 && (a *= 256);) this[n + u] = r / a & 255;
  return n + e
};
o.prototype.writeUInt8 = function (r, n, e)
{
  return r = +r, n = n | 0, e || w(this, r, n, 1, 255, 0), o.TYPED_ARRAY_SUPPORT || (r = Math.floor(r)), this[n] = r & 255, n + 1
};

function D(i, r, n, e)
{
  r < 0 && (r = 65535 + r + 1);
  for (var t = 0, f = Math.min(i.length - n, 2); t < f; ++t) i[n + t] = (r & 255 << 8 * (e ? t : 1 - t)) >>> (e ? t : 1 - t) * 8
}
o.prototype.writeUInt16LE = function (r, n, e)
{
  return r = +r, n = n | 0, e || w(this, r, n, 2, 65535, 0), o.TYPED_ARRAY_SUPPORT ? (this[n] = r & 255, this[n + 1] = r >>> 8) : D(this, r, n, !0), n + 2
};
o.prototype.writeUInt16BE = function (r, n, e)
{
  return r = +r, n = n | 0, e || w(this, r, n, 2, 65535, 0), o.TYPED_ARRAY_SUPPORT ? (this[n] = r >>> 8, this[n + 1] = r & 255) : D(this, r, n, !1), n + 2
};

function C(i, r, n, e)
{
  r < 0 && (r = 4294967295 + r + 1);
  for (var t = 0, f = Math.min(i.length - n, 4); t < f; ++t) i[n + t] = r >>> (e ? t : 3 - t) * 8 & 255
}
o.prototype.writeUInt32LE = function (r, n, e)
{
  return r = +r, n = n | 0, e || w(this, r, n, 4, 4294967295, 0), o.TYPED_ARRAY_SUPPORT ? (this[n + 3] = r >>> 24, this[n + 2] = r >>> 16, this[n + 1] = r >>> 8, this[n] = r & 255) : C(this, r, n, !0), n + 4
};
o.prototype.writeUInt32BE = function (r, n, e)
{
  return r = +r, n = n | 0, e || w(this, r, n, 4, 4294967295, 0), o.TYPED_ARRAY_SUPPORT ? (this[n] = r >>> 24, this[n + 1] = r >>> 16, this[n + 2] = r >>> 8, this[n + 3] = r & 255) : C(this, r, n, !1), n + 4
};
o.prototype.writeIntLE = function (r, n, e, t)
{
  if (r = +r, n = n | 0, !t)
  {
    var f = Math.pow(2, 8 * e - 1);
    w(this, r, n, e, f - 1, -f)
  }
  var u = 0,
    a = 1,
    h = 0;
  for (this[n] = r & 255; ++u < e && (a *= 256);) r < 0 && h === 0 && this[n + u - 1] !== 0 && (h = 1), this[n + u] = (r / a >> 0) - h & 255;
  return n + e
};
o.prototype.writeIntBE = function (r, n, e, t)
{
  if (r = +r, n = n | 0, !t)
  {
    var f = Math.pow(2, 8 * e - 1);
    w(this, r, n, e, f - 1, -f)
  }
  var u = e - 1,
    a = 1,
    h = 0;
  for (this[n + u] = r & 255; --u >= 0 && (a *= 256);) r < 0 && h === 0 && this[n + u + 1] !== 0 && (h = 1), this[n + u] = (r / a >> 0) - h & 255;
  return n + e
};
o.prototype.writeInt8 = function (r, n, e)
{
  return r = +r, n = n | 0, e || w(this, r, n, 1, 127, -128), o.TYPED_ARRAY_SUPPORT || (r = Math.floor(r)), r < 0 && (r = 255 + r + 1), this[n] = r & 255, n + 1
};
o.prototype.writeInt16LE = function (r, n, e)
{
  return r = +r, n = n | 0, e || w(this, r, n, 2, 32767, -32768), o.TYPED_ARRAY_SUPPORT ? (this[n] = r & 255, this[n + 1] = r >>> 8) : D(this, r, n, !0), n + 2
};
o.prototype.writeInt16BE = function (r, n, e)
{
  return r = +r, n = n | 0, e || w(this, r, n, 2, 32767, -32768), o.TYPED_ARRAY_SUPPORT ? (this[n] = r >>> 8, this[n + 1] = r & 255) : D(this, r, n, !1), n + 2
};
o.prototype.writeInt32LE = function (r, n, e)
{
  return r = +r, n = n | 0, e || w(this, r, n, 4, 2147483647, -2147483648), o.TYPED_ARRAY_SUPPORT ? (this[n] = r & 255, this[n + 1] = r >>> 8, this[n + 2] = r >>> 16, this[n + 3] = r >>> 24) : C(this, r, n, !0), n + 4
};
o.prototype.writeInt32BE = function (r, n, e)
{
  return r = +r, n = n | 0, e || w(this, r, n, 4, 2147483647, -2147483648), r < 0 && (r = 4294967295 + r + 1), o.TYPED_ARRAY_SUPPORT ? (this[n] = r >>> 24, this[n + 1] = r >>> 16, this[n + 2] = r >>> 8, this[n + 3] = r & 255) : C(this, r, n, !1), n + 4
};

function fr(i, r, n, e, t, f)
{
  if (n + e > i.length) throw new RangeError("Index out of range");
  if (n < 0) throw new RangeError("Index out of range")
}

function ur(i, r, n, e, t)
{
  return t || fr(i, r, n, 4, 34028234663852886e22, -34028234663852886e22), cr(i, r, n, e, 23, 4), n + 4
}
o.prototype.writeFloatLE = function (r, n, e)
{
  return ur(this, r, n, !0, e)
};
o.prototype.writeFloatBE = function (r, n, e)
{
  return ur(this, r, n, !1, e)
};

function or(i, r, n, e, t)
{
  return t || fr(i, r, n, 8, 17976931348623157e292, -17976931348623157e292), cr(i, r, n, e, 52, 8), n + 8
}
o.prototype.writeDoubleLE = function (r, n, e)
{
  return or(this, r, n, !0, e)
};
o.prototype.writeDoubleBE = function (r, n, e)
{
  return or(this, r, n, !1, e)
};
o.prototype.copy = function (r, n, e, t)
{
  if (e || (e = 0), !t && t !== 0 && (t = this.length), n >= r.length && (n = r.length), n || (n = 0), t > 0 && t < e && (t = e), t === e || r.length === 0 || this.length === 0) return 0;
  if (n < 0) throw new RangeError("targetStart out of bounds");
  if (e < 0 || e >= this.length) throw new RangeError("sourceStart out of bounds");
  if (t < 0) throw new RangeError("sourceEnd out of bounds");
  t > this.length && (t = this.length), r.length - n < t - e && (t = r.length - n + e);
  var f = t - e,
    u;
  if (this === r && e < n && n < t)
    for (u = f - 1; u >= 0; --u) r[u + n] = this[u + e];
  else if (f < 1e3 || !o.TYPED_ARRAY_SUPPORT)
    for (u = 0; u < f; ++u) r[u + n] = this[u + e];
  else Uint8Array.prototype.set.call(r, this.subarray(e, e + f), n);
  return f
};
o.prototype.fill = function (r, n, e, t)
{
  if (typeof r == "string")
  {
    if (typeof n == "string" ? (t = n, n = 0, e = this.length) : typeof e == "string" && (t = e, e = this.length), r.length === 1)
    {
      var f = r.charCodeAt(0);
      f < 256 && (r = f)
    }
    if (t !== void 0 && typeof t != "string") throw new TypeError("encoding must be a string");
    if (typeof t == "string" && !o.isEncoding(t)) throw new TypeError("Unknown encoding: " + t)
  }
  else typeof r == "number" && (r = r & 255);
  if (n < 0 || this.length < n || this.length < e) throw new RangeError("Out of range index");
  if (e <= n) return this;
  n = n >>> 0, e = e === void 0 ? this.length : e >>> 0, r || (r = 0);
  var u;
  if (typeof r == "number")
    for (u = n; u < e; ++u) this[u] = r;
  else
  {
    var a = g(r) ? r : M(new o(r, t).toString()),
      h = a.length;
    for (u = 0; u < e - n; ++u) this[u + n] = a[u % h]
  }
  return this
};
var pn = /[^+\/0-9A-Za-z-_]/g;

function sn(i)
{
  if (i = wn(i).replace(pn, ""), i.length < 2) return "";
  for (; i.length % 4 !== 0;) i = i + "=";
  return i
}

function wn(i)
{
  return i.trim ? i.trim() : i.replace(/^\s+|\s+$/g, "")
}

function xn(i)
{
  return i < 16 ? "0" + i.toString(16) : i.toString(16)
}

function M(i, r)
{
  r = r || 1 / 0;
  for (var n, e = i.length, t = null, f = [], u = 0; u < e; ++u)
  {
    if (n = i.charCodeAt(u), n > 55295 && n < 57344)
    {
      if (!t)
      {
        if (n > 56319)
        {
          (r -= 3) > -1 && f.push(239, 191, 189);
          continue
        }
        else if (u + 1 === e)
        {
          (r -= 3) > -1 && f.push(239, 191, 189);
          continue
        }
        t = n;
        continue
      }
      if (n < 56320)
      {
        (r -= 3) > -1 && f.push(239, 191, 189), t = n;
        continue
      }
      n = (t - 55296 << 10 | n - 56320) + 65536
    }
    else t && (r -= 3) > -1 && f.push(239, 191, 189);
    if (t = null, n < 128)
    {
      if ((r -= 1) < 0) break;
      f.push(n)
    }
    else if (n < 2048)
    {
      if ((r -= 2) < 0) break;
      f.push(n >> 6 | 192, n & 63 | 128)
    }
    else if (n < 65536)
    {
      if ((r -= 3) < 0) break;
      f.push(n >> 12 | 224, n >> 6 & 63 | 128, n & 63 | 128)
    }
    else if (n < 1114112)
    {
      if ((r -= 4) < 0) break;
      f.push(n >> 18 | 240, n >> 12 & 63 | 128, n >> 6 & 63 | 128, n & 63 | 128)
    }
    else throw new Error("Invalid code point")
  }
  return f
}

function En(i)
{
  for (var r = [], n = 0; n < i.length; ++n) r.push(i.charCodeAt(n) & 255);
  return r
}

function mn(i, r)
{
  for (var n, e, t, f = [], u = 0; u < i.length && !((r -= 2) < 0); ++u) n = i.charCodeAt(u), e = n >> 8, t = n % 256, f.push(t), f.push(e);
  return f
}

function ar(i)
{
  return Qr(sn(i))
}

function k(i, r, n, e)
{
  for (var t = 0; t < e && !(t + n >= r.length || t >= i.length); ++t) r[t + n] = i[t];
  return t
}

function An(i)
{
  return i !== i
}

function gn(i)
{
  return i != null && (!!i._isBuffer || hr(i) || yn(i))
}

function hr(i)
{
  return !!i.constructor && typeof i.constructor.isBuffer == "function" && i.constructor.isBuffer(i)
}

function yn(i)
{
  return typeof i.readFloatLE == "function" && typeof i.slice == "function" && hr(i.slice(0, 0))
}

function N(i, r, n, e, t)
{
  var f, u, a = t * 8 - e - 1,
    h = (1 << a) - 1,
    l = h >> 1,
    p = -7,
    c = n ? t - 1 : 0,
    m = n ? -1 : 1,
    x = i[r + c];
  for (c += m, f = x & (1 << -p) - 1, x >>= -p, p += a; p > 0; f = f * 256 + i[r + c], c += m, p -= 8);
  for (u = f & (1 << -p) - 1, f >>= -p, p += e; p > 0; u = u * 256 + i[r + c], c += m, p -= 8);
  if (f === 0) f = 1 - l;
  else
  {
    if (f === h) return u ? NaN : (x ? -1 : 1) * (1 / 0);
    u = u + Math.pow(2, e), f = f - l
  }
  return (x ? -1 : 1) * u * Math.pow(2, f - e)
}

function cr(i, r, n, e, t, f)
{
  var u, a, h, l = f * 8 - t - 1,
    p = (1 << l) - 1,
    c = p >> 1,
    m = t === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0,
    x = e ? 0 : f - 1,
    B = e ? 1 : -1,
    lr = r < 0 || r === 0 && 1 / r < 0 ? 1 : 0;
  for (r = Math.abs(r), isNaN(r) || r === 1 / 0 ? (a = isNaN(r) ? 1 : 0, u = p) : (u = Math.floor(Math.log(r) / Math.LN2), r * (h = Math.pow(2, -u)) < 1 && (u--, h *= 2), u + c >= 1 ? r += m / h : r += m * Math.pow(2, 1 - c), r * h >= 2 && (u++, h /= 2), u + c >= p ? (a = 0, u = p) : u + c >= 1 ? (a = (r * h - 1) * Math.pow(2, t), u = u + c) : (a = r * Math.pow(2, c - 1) * Math.pow(2, t), u = 0)); t >= 8; i[n + x] = a & 255, x += B, a /= 256, t -= 8);
  for (u = u << t | a, l += t; l > 0; i[n + x] = u & 255, x += B, u /= 256, l -= 8);
  i[n + x - B] |= lr * 128
}

function Tn(i)
{}
/*! Bundled license information:

@esbuild-plugins/node-globals-polyfill/Buffer.js:
  (*!
   * The buffer module from node.js, for the browser.
   *
   * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
   * @license  MIT
   *)
*/

solomonkinard.git-blame

Metadata

Publisher

Statistics

Files

Code