diff options
Diffstat (limited to 'straight/build-cache.el')
| -rw-r--r-- | straight/build-cache.el | 709 |
1 files changed, 709 insertions, 0 deletions
diff --git a/straight/build-cache.el b/straight/build-cache.el new file mode 100644 index 0000000..0988783 --- /dev/null +++ b/straight/build-cache.el @@ -0,0 +1,709 @@ + +:tanat + +"30.2" + +#s(hash-table test equal data ("straight" ("2025-12-10 14:34:06" ("emacs") (:type git :host github :repo "radian-software/straight.el" :files ("straight*.el") :branch "main" :package "straight" :local-repo "straight.el")) "org-elpa" ("2025-12-10 14:34:06" nil (:local-repo nil :package "org-elpa" :type git)) "melpa" ("2025-12-10 14:34:06" nil (:type git :host github :repo "melpa/melpa" :build nil :package "melpa" :local-repo "melpa")) "gnu-elpa-mirror" ("2025-12-10 14:34:08" nil (:type git :host github :repo "emacs-straight/gnu-elpa-mirror" :build nil :package "gnu-elpa-mirror" :local-repo "gnu-elpa-mirror")) "use-package" ("2025-12-10 14:34:12" ("emacs" "bind-key") (:type git :host github :repo "emacs-straight/use-package" :files ("*" (:exclude ".git")) :package "use-package" :local-repo "use-package")) "bind-key" ("2025-12-10 14:34:11" ("emacs") (:type git :host github :repo "emacs-straight/bind-key" :files ("*" (:exclude ".git")) :package "bind-key" :local-repo "bind-key")) "diminish" ("2025-12-10 14:34:13" ("emacs") (:type git :host github :repo "emacs-straight/diminish" :files ("*" (:exclude ".git")) :package "diminish" :local-repo "diminish")) "nongnu-elpa" ("2025-12-10 14:47:08" nil (:type git :repo "https://github.com/emacsmirror/nongnu_elpa.git" :depth (full single-branch) :local-repo "nongnu-elpa" :build nil :package "nongnu-elpa")) "evil" ("2025-12-10 14:47:20" ("emacs" "cl-lib" "goto-chg" "nadvice") (:repo "https://github.com/emacs-evil/evil" :files (:defaults (:exclude "COPYING" "lib" "scripts")) :package "evil" :type git :local-repo "evil")) "el-get" ("2025-12-10 14:47:16" nil (:type git :host github :repo "dimitri/el-get" :build nil :package "el-get" :local-repo "el-get")) "emacsmirror-mirror" ("2025-12-10 14:47:17" nil (:type git :host github :repo "emacs-straight/emacsmirror-mirror" :build nil :package "emacsmirror-mirror" :local-repo "emacsmirror-mirror")) "goto-chg" ("2025-12-10 14:47:19" ("emacs") (:repo "https://github.com/emacs-evil/goto-chg" :files (:defaults (:exclude "LICENSE")) :package "goto-chg" :type git :local-repo "goto-chg")) "evil-collection" ("2025-12-10 15:00:26" ("emacs" "evil" "annalist") (:type git :host github :repo "emacs-evil/evil-collection" :files (:defaults "modes") :package "evil-collection" :local-repo "evil-collection")) "annalist" ("2025-12-10 14:47:24" ("emacs" "cl-lib") (:type git :host github :repo "emacsmirror/annalist" :package "annalist" :local-repo "annalist")) "ultra-scroll" ("2025-12-10 17:06:48" ("emacs") (:type git :host github :repo "emacsmirror/ultra-scroll" :package "ultra-scroll" :local-repo "ultra-scroll")))) + +#s(hash-table test equal data ("straight" ((straight-autoloads straight straight-x straight-ert-print-hack) (autoload 'straight-remove-unused-repos "straight" "Remove unused repositories from the repos and build directories. +A repo is considered \"unused\" if it was not explicitly requested via +`straight-use-package' during the current Emacs session. +If FORCE is non-nil do not prompt before deleting repos. + +(fn &optional FORCE)" t) (autoload 'straight-get-recipe "straight" "Interactively select a recipe from one of the recipe repositories. +All recipe repositories in `straight-recipe-repositories' will +first be cloned. After the recipe is selected, it will be copied +to the kill ring. With a prefix argument, first prompt for a +recipe repository to search. Only that repository will be +cloned. + +From Lisp code, SOURCES should be a subset of the symbols in +`straight-recipe-repositories'. Only those recipe repositories +are cloned and searched. If it is nil or omitted, then the value +of `straight-recipe-repositories' is used. If SOURCES is the +symbol `interactive', then the user is prompted to select a +recipe repository, and a list containing that recipe repository +is used for the value of SOURCES. ACTION may be `copy' (copy +recipe to the kill ring), `insert' (insert at point), or nil (no +action, just return it). + +Optional arg FILTER must be a unary function. +It takes a package name as its sole argument. +If it returns nil the candidate is excluded. + +USE-CACHE non-nil means respect the existing straight.el recipe cache, +i.e. display also packages that have been registered in the current +Emacs session even if not found in any recipe repository, and if such a +package is selected, return just the package name as a symbol, instead +of a recipe. (It is not possible to return an actual recipe, as the API +for `straight-get-recipe' returns MELPA-style recipes, while cached +recipes have already been converted into the internal format.) + +Within `straight-get-recipe', the symbol `cache' is treated as if it is +also a member of `straight-recipe-repositories', and refers to the set +of packages that have already been registered in the current Emacs +session. + +(fn &optional SOURCES ACTION FILTER USE-CACHE)" t) (autoload 'straight-visit-package-website "straight" "Visit the package RECIPE's website. + +(fn RECIPE)" t) (autoload 'straight-visit-package "straight" "Open PACKAGE's local repository directory. +When BUILD is non-nil visit PACKAGE's build directory. + +(fn PACKAGE &optional BUILD)" t) (autoload 'straight-use-package "straight" "Register, clone, build, and activate a package and its dependencies. +This is the main entry point to the functionality of straight.el. + +MELPA-STYLE-RECIPE is either a symbol naming a package, or a list +whose car is a symbol naming a package and whose cdr is a +property list containing e.g. `:type', `:local-repo', `:files', +and VC backend specific keywords. + +First, the package recipe is registered with straight.el. If +NO-CLONE is a function, then it is called with two arguments: the +package name as a string, and a boolean value indicating whether +the local repository for the package is available. In that case, +the return value of the function is used as the value of NO-CLONE +instead. In any case, if NO-CLONE is non-nil, then processing +stops here. + +Otherwise, the repository is cloned, if it is missing. If +NO-BUILD is a function, then it is called with one argument: the +package name as a string. In that case, the return value of the +function is used as the value of NO-BUILD instead. In any case, +if NO-BUILD is non-nil, then processing halts here. Otherwise, +the package is built and activated. Note that if the package +recipe has a nil `:build' entry, then NO-BUILD is ignored +and processing always stops before building and activation +occurs. + +CAUSE is a string explaining the reason why +`straight-use-package' has been called. It is for internal use +only, and is used to construct progress messages. INTERACTIVE is +non-nil if the function has been called interactively. It is for +internal use only, and is used to determine whether to show a +hint about how to install the package permanently. + +Return non-nil when package is initially installed, nil otherwise. + +Interactively, prompt with a list of available packages in currently +registered recipe repositories. With prefix arg, prompt first for which +recipe repository to list from. If a package has already been registered +in the current Emacs session, the existing recipe is re-used rather than +being looked up anew. With prefix arg, \"cache\" is displayed as one of +the recipe repositories, and allows filtering to only already-registered +packages. + +(fn MELPA-STYLE-RECIPE &optional NO-CLONE NO-BUILD CAUSE INTERACTIVE)" t) (autoload 'straight-register-package "straight" "Register a package without cloning, building, or activating it. +This function is equivalent to calling `straight-use-package' +with a non-nil argument for NO-CLONE. It is provided for +convenience. MELPA-STYLE-RECIPE is as for +`straight-use-package'. + +(fn MELPA-STYLE-RECIPE)") (autoload 'straight-use-package-no-build "straight" "Register and clone a package without building it. +This function is equivalent to calling `straight-use-package' +with nil for NO-CLONE but a non-nil argument for NO-BUILD. It is +provided for convenience. MELPA-STYLE-RECIPE is as for +`straight-use-package'. + +(fn MELPA-STYLE-RECIPE)") (autoload 'straight-use-package-lazy "straight" "Register, build, and activate a package if it is already cloned. +This function is equivalent to calling `straight-use-package' +with symbol `lazy' for NO-CLONE. It is provided for convenience. +MELPA-STYLE-RECIPE is as for `straight-use-package'. + +Argument CAUSE is for internal use only. + +(fn MELPA-STYLE-RECIPE &optional CAUSE)") (autoload 'straight-use-recipes "straight" "Register a recipe repository using MELPA-STYLE-RECIPE. +This registers the recipe and builds it if it is already cloned. +Note that you probably want the recipe for a recipe repository to +include a nil `:build' property, to unconditionally +inhibit the build phase. + +This function also adds the recipe repository to +`straight-recipe-repositories', at the end of the list. + +Existing recipe repositories are not searched for a recipe for the +recipe repository you are trying to register, because that is strange +and confusing. If you explicitly want this behavior, you can use the +`straight-use-package' API directly. + +Argument CAUSE is for internal use only. + +(fn MELPA-STYLE-RECIPE &optional CAUSE)") (autoload 'straight-override-recipe "straight" "Register MELPA-STYLE-RECIPE as a recipe override. +This puts it in `straight-recipe-overrides', depending on the +value of `straight-current-profile'. + +(fn MELPA-STYLE-RECIPE)") (autoload 'straight-check-package "straight" "Rebuild a PACKAGE if it has been modified. +PACKAGE is a string naming a package. Interactively, select +PACKAGE from the known packages in the current Emacs session +using `completing-read'. See also `straight-rebuild-package' and +`straight-check-all'. + +(fn PACKAGE)" t) (autoload 'straight-check-all "straight" "Rebuild any packages that have been modified. +See also `straight-rebuild-all' and `straight-check-package'. +This function should not be called during init." t) (autoload 'straight-rebuild-package "straight" "Rebuild a PACKAGE. +PACKAGE is a string naming a package. Interactively, select +PACKAGE from the known packages in the current Emacs session +using `completing-read'. With prefix argument RECURSIVE, rebuild +all dependencies as well. See also `straight-check-package' and +`straight-rebuild-all'. + +(fn PACKAGE &optional RECURSIVE)" t) (autoload 'straight-rebuild-all "straight" "Rebuild all packages. +See also `straight-check-all' and `straight-rebuild-package'." t) (autoload 'straight-prune-build-cache "straight" "Prune the build cache. +This means that only packages that were built in the last init +run and subsequent interactive session will remain; other +packages will have their build mtime information and any cached +autoloads discarded.") (autoload 'straight-prune-build-directory "straight" "Prune the build directory. +This means that only packages that were built in the last init +run and subsequent interactive session will remain; other +packages will have their build directories deleted.") (autoload 'straight-prune-build "straight" "Prune the build cache and build directory. +This means that only packages that were built in the last init +run and subsequent interactive session will remain; other +packages will have their build mtime information discarded and +their build directories deleted." t) (autoload 'straight-normalize-package "straight" "Normalize a PACKAGE's local repository to its recipe's configuration. +PACKAGE is a string naming a package. Interactively, select +PACKAGE from the known packages in the current Emacs session +using `completing-read'. + +CONVERT-SNAPSHOTS non-nil (interactively, prefix arg) means if the +repository is a snapshot, convert it to a full repository first. + +(fn PACKAGE &key CONVERT-SNAPSHOTS)" t) (autoload 'straight-normalize-all "straight" "Normalize all packages. See `straight-normalize-package'. +Return a list of recipes for packages that were not successfully +normalized. If multiple packages come from the same local +repository, only one is normalized. + +PREDICATE, if provided, filters the packages that are normalized. +It is called with the package name as a string, and should return +non-nil if the package should actually be normalized. + +CONVERT-SNAPSHOTS non-nil (interactively, prefix arg) means if +repositories are snapshots, convert them to full repositories first. + +(fn &optional PREDICATE CONVERT-SNAPSHOTS)" t) (autoload 'straight-fetch-package "straight" "Try to fetch a PACKAGE from the primary remote. +PACKAGE is a string naming a package. Interactively, select +PACKAGE from the known packages in the current Emacs session +using `completing-read'. With prefix argument FROM-UPSTREAM, +fetch not just from primary remote but also from upstream (for +forked packages). + +(fn PACKAGE &optional FROM-UPSTREAM)" t) (autoload 'straight-fetch-package-and-deps "straight" "Try to fetch a PACKAGE and its (transitive) dependencies. +PACKAGE, its dependencies, their dependencies, etc. are fetched +from their primary remotes. + +PACKAGE is a string naming a package. Interactively, select +PACKAGE from the known packages in the current Emacs session +using `completing-read'. With prefix argument FROM-UPSTREAM, +fetch not just from primary remote but also from upstream (for +forked packages). + +(fn PACKAGE &optional FROM-UPSTREAM)" t) (autoload 'straight-fetch-all "straight" "Try to fetch all packages from their primary remotes. +With prefix argument FROM-UPSTREAM, fetch not just from primary +remotes but also from upstreams (for forked packages). + +Return a list of recipes for packages that were not successfully +fetched. If multiple packages come from the same local +repository, only one is fetched. + +PREDICATE, if provided, filters the packages that are fetched. It +is called with the package name as a string, and should return +non-nil if the package should actually be fetched. + +(fn &optional FROM-UPSTREAM PREDICATE)" t) (autoload 'straight-merge-package "straight" "Try to merge a PACKAGE from the primary remote. +PACKAGE is a string naming a package. Interactively, select +PACKAGE from the known packages in the current Emacs session +using `completing-read'. With prefix argument FROM-UPSTREAM, +merge not just from primary remote but also from upstream (for +forked packages). + +(fn PACKAGE &optional FROM-UPSTREAM)" t) (autoload 'straight-merge-package-and-deps "straight" "Try to merge a PACKAGE and its (transitive) dependencies. +PACKAGE, its dependencies, their dependencies, etc. are merged +from their primary remotes. + +PACKAGE is a string naming a package. Interactively, select +PACKAGE from the known packages in the current Emacs session +using `completing-read'. With prefix argument FROM-UPSTREAM, +merge not just from primary remote but also from upstream (for +forked packages). + +(fn PACKAGE &optional FROM-UPSTREAM)" t) (autoload 'straight-merge-all "straight" "Try to merge all packages from their primary remotes. +With prefix argument FROM-UPSTREAM, merge not just from primary +remotes but also from upstreams (for forked packages). + +Return a list of recipes for packages that were not successfully +merged. If multiple packages come from the same local +repository, only one is merged. + +PREDICATE, if provided, filters the packages that are merged. It +is called with the package name as a string, and should return +non-nil if the package should actually be merged. + +(fn &optional FROM-UPSTREAM PREDICATE)" t) (autoload 'straight-pull-package "straight" "Try to pull a PACKAGE from the primary remote. +PACKAGE is a string naming a package. Interactively, select +PACKAGE from the known packages in the current Emacs session +using `completing-read'. With prefix argument FROM-UPSTREAM, pull +not just from primary remote but also from upstream (for forked +packages). + +(fn PACKAGE &optional FROM-UPSTREAM)" t) (autoload 'straight-pull-package-and-deps "straight" "Try to pull a PACKAGE and its (transitive) dependencies. +PACKAGE, its dependencies, their dependencies, etc. are pulled +from their primary remotes. + +PACKAGE is a string naming a package. Interactively, select +PACKAGE from the known packages in the current Emacs session +using `completing-read'. With prefix argument FROM-UPSTREAM, +pull not just from primary remote but also from upstream (for +forked packages). + +(fn PACKAGE &optional FROM-UPSTREAM)" t) (autoload 'straight-pull-all "straight" "Try to pull all packages from their primary remotes. +With prefix argument FROM-UPSTREAM, pull not just from primary +remotes but also from upstreams (for forked packages). + +Return a list of recipes for packages that were not successfully +pulled. If multiple packages come from the same local repository, +only one is pulled. + +PREDICATE, if provided, filters the packages that are pulled. It +is called with the package name as a string, and should return +non-nil if the package should actually be pulled. + +(fn &optional FROM-UPSTREAM PREDICATE)" t) (autoload 'straight-push-package "straight" "Push a PACKAGE to its primary remote, if necessary. +PACKAGE is a string naming a package. Interactively, select +PACKAGE from the known packages in the current Emacs session +using `completing-read'. + +(fn PACKAGE)" t) (autoload 'straight-push-all "straight" "Try to push all packages to their primary remotes. + +Return a list of recipes for packages that were not successfully +pushed. If multiple packages come from the same local repository, +only one is pushed. + +PREDICATE, if provided, filters the packages that are normalized. +It is called with the package name as a string, and should return +non-nil if the package should actually be normalized. + +(fn &optional PREDICATE)" t) (autoload 'straight-freeze-versions "straight" "Write version lockfiles for currently activated packages. +This implies first pushing all packages that have unpushed local +changes. If the package management system has been used since the +last time the init-file was reloaded, offer to fix the situation +by reloading the init-file again. If FORCE is +non-nil (interactively, if a prefix argument is provided), skip +all checks and write the lockfile anyway. + +Currently, writing version lockfiles requires cloning all lazily +installed packages. Hopefully, this inconvenient requirement will +be removed in the future. + +Multiple lockfiles may be written (one for each profile), +according to the value of `straight-profiles'. + +(fn &optional FORCE)" t) (autoload 'straight-thaw-versions "straight" "Read version lockfiles and restore package versions to those listed." t) (autoload 'straight-bug-report "straight" "Test straight.el in a clean environment. +ARGS may be any of the following keywords and their respective values: + - :pre-bootstrap (Form)... + Forms evaluated before bootstrapping straight.el + e.g. (setq straight-repository-branch \"develop\") + Note this example is already in the default bootstrapping code. + + - :post-bootstrap (Form)... + Forms evaluated in the testing environment after boostrapping. + e.g. (straight-use-package \\='(example :type git :host github)) + + - :interactive Boolean + If nil, the subprocess will immediately exit after the test. + Output will be printed to `straight-bug-report--process-buffer' + Otherwise, the subprocess will be interactive. + + - :preserve Boolean + If non-nil, the test directory is left in the directory stored in the + variable `temporary-file-directory'. Otherwise, it is + immediately removed after the test is run. + + - :executable String + Indicate the Emacs executable to launch. + Defaults to the path of the current Emacs executable. + + - :raw Boolean + If non-nil, the raw process output is sent to + `straight-bug-report--process-buffer'. Otherwise, it is + formatted as markdown for submitting as an issue. + + - :user-dir String + If non-nil, the test is run with `user-emacs-directory' set to STRING. + Otherwise, a temporary directory is created and used. + Unless absolute, paths are expanded relative to the variable + `temporary-file-directory'. + +ARGS are accessible within the :pre/:post-bootsrap phases via the +locally bound plist, straight-bug-report-args. + +(fn &rest ARGS)" nil t) (function-put 'straight-bug-report 'lisp-indent-function 0) (autoload 'straight-dependencies "straight" "Return a list of PACKAGE's dependencies, as strings. +PACKAGE is a string. If the dependencies have dependencies themselves, +then instead of strings they will be lists whose cars are the +dependencies and whose cdrs are the recursive dependencies in the same +format returned from `straight-dependencies'. + +Interactively, the user selects a package to show dependencies for, and +the dependencies are shown in the echo area. + +(fn &optional PACKAGE)" t) (autoload 'straight-dependents "straight" "Return a list of PACKAGE's dependents, as strings. +Dependents are packages that have the given package as a dependency. In +other words, this is the opposite of `straight-dependencies'. + +PACKAGE is a string. If the dependents have dependents themselves, then +instead of strings they will be lists whose cars are the dependents and +whose cdrs are the recursive dependents in the same format returned from +`straight-dependents'. + +(fn &optional PACKAGE)" t) (register-definition-prefixes "straight" '("straight-")) (register-definition-prefixes "straight-ert-print-hack" '("+without-print-limits")) (defvar straight-x-pinned-packages nil "List of pinned packages.") (register-definition-prefixes "straight-x" '("straight-x-")) (provide 'straight-autoloads)) "bind-key" ((bind-key-autoloads bind-key bind-key-pkg) (defvar personal-keybindings nil "List of bindings performed by `bind-key'. + +Elements have the form ((KEY . [MAP]) CMD ORIGINAL-CMD)") (autoload 'bind-key "bind-key" "Bind KEY-NAME to COMMAND in KEYMAP (`global-map' if not passed). + +KEY-NAME may be a vector, in which case it is passed straight to +`define-key'. Or it may be a string to be interpreted as +spelled-out keystrokes, e.g., \"C-c C-z\". See the documentation +of `edmacro-mode' for details. + +COMMAND must be an interactive function or lambda form. + +KEYMAP, if present, should be a keymap variable or symbol. +For example: + + (bind-key \"M-h\" #\\='some-interactive-function my-mode-map) + + (bind-key \"M-h\" #\\='some-interactive-function \\='my-mode-map) + +If PREDICATE is non-nil, it is a form evaluated to determine when +a key should be bound. It must return non-nil in such cases. +Emacs can evaluate this form at any time that it does redisplay +or operates on menu data structures, so you should write it so it +can safely be called at any time. + +(fn KEY-NAME COMMAND &optional KEYMAP PREDICATE)" nil t) (autoload 'unbind-key "bind-key" "Unbind the given KEY-NAME, within the KEYMAP (if specified). +See `bind-key' for more details. + +(fn KEY-NAME &optional KEYMAP)" nil t) (autoload 'bind-key* "bind-key" "Similar to `bind-key', but overrides any mode-specific bindings. + +(fn KEY-NAME COMMAND &optional PREDICATE)" nil t) (autoload 'bind-keys "bind-key" "Bind multiple keys at once. + +Accepts keyword arguments: +:map MAP - a keymap into which the keybindings should be + added +:prefix KEY - prefix key for these bindings +:prefix-map MAP - name of the prefix map that should be created + for these bindings +:prefix-docstring STR - docstring for the prefix-map variable +:menu-name NAME - optional menu string for prefix map +:repeat-docstring STR - docstring for the repeat-map variable +:repeat-map MAP - name of the repeat map that should be created + for these bindings. If specified, the + `repeat-map' property of each command bound + (within the scope of the `:repeat-map' keyword) + is set to this map. +:exit BINDINGS - Within the scope of `:repeat-map' will bind the + key in the repeat map, but will not set the + `repeat-map' property of the bound command. +:continue BINDINGS - Within the scope of `:repeat-map' forces the + same behavior as if no special keyword had + been used (that is, the command is bound, and + it's `repeat-map' property set) +:continue-only BINDINGS - Within the scope of `:repeat-map', will make + the command continue but not enter the repeat + map, via the `repeat-continue' property +:filter FORM - optional form to determine when bindings apply + +The rest of the arguments are conses of keybinding string and a +function symbol (unquoted). + +(fn &rest ARGS)" nil t) (autoload 'bind-keys* "bind-key" "Bind multiple keys at once, in `override-global-map'. +Accepts the same keyword arguments as `bind-keys' (which see). + +This binds keys in such a way that bindings are not overridden by +other modes. See `override-global-mode'. + +(fn &rest ARGS)" nil t) (autoload 'describe-personal-keybindings "bind-key" "Display all the personal keybindings defined by `bind-key'." t) (register-definition-prefixes "bind-key" '("bind-key" "override-global-m")) (provide 'bind-key-autoloads)) "use-package" ((use-package-autoloads use-package use-package-pkg use-package-lint use-package-jump use-package-ensure use-package-ensure-system-package use-package-diminish use-package-delight use-package-core use-package-bind-key) (autoload 'use-package-autoload-keymap "use-package-bind-key" "Load PACKAGE and bind key sequence invoking this function to KEYMAP-SYMBOL. +Then simulate pressing the same key sequence a again, so that the +next key pressed is routed to the newly loaded keymap. + +This function supports use-package's :bind-keymap keyword. It +works by binding the given key sequence to an invocation of this +function for a particular keymap. The keymap is expected to be +defined by the package. In this way, loading the package is +deferred until the prefix key sequence is pressed. + +(fn KEYMAP-SYMBOL PACKAGE OVERRIDE)") (autoload 'use-package-normalize-binder "use-package-bind-key" " + +(fn NAME KEYWORD ARGS)") (defalias 'use-package-normalize/:bind 'use-package-normalize-binder) (defalias 'use-package-normalize/:bind* 'use-package-normalize-binder) (defalias 'use-package-autoloads/:bind 'use-package-autoloads-mode) (defalias 'use-package-autoloads/:bind* 'use-package-autoloads-mode) (autoload 'use-package-handler/:bind "use-package-bind-key" " + +(fn NAME KEYWORD ARGS REST STATE &optional BIND-MACRO)") (defalias 'use-package-normalize/:bind-keymap 'use-package-normalize-binder) (defalias 'use-package-normalize/:bind-keymap* 'use-package-normalize-binder) (autoload 'use-package-handler/:bind-keymap "use-package-bind-key" " + +(fn NAME KEYWORD ARGS REST STATE &optional OVERRIDE)") (autoload 'use-package-handler/:bind-keymap* "use-package-bind-key" " + +(fn NAME KEYWORD ARG REST STATE)") (register-definition-prefixes "use-package-bind-key" '("use-package-handler/:bind*")) (autoload 'use-package "use-package-core" "Declare an Emacs package by specifying a group of configuration options. + +For the full documentation, see Info node `(use-package) top'. +Usage: + + (use-package package-name + [:keyword [option]]...) + +:init Code to run before PACKAGE-NAME has been loaded. +:config Code to run after PACKAGE-NAME has been loaded. Note that + if loading is deferred for any reason, this code does not + execute until the lazy load has occurred. +:preface Code to be run before everything except `:disabled'; this + can be used to define functions for use in `:if', or that + should be seen by the byte-compiler. + +:mode Form to be added to `auto-mode-alist'. +:magic Form to be added to `magic-mode-alist'. +:magic-fallback Form to be added to `magic-fallback-mode-alist'. +:interpreter Form to be added to `interpreter-mode-alist'. + +:commands Define autoloads for commands defined by the package. + This is useful if the package is being lazily loaded, + and you wish to conditionally call functions in your + `:init' block that are defined in the package. +:autoload Similar to `:commands', but used for non-interactive functions. +:hook Specify hook(s) to attach this package to. + +:bind Bind keys, and define autoloads for the bound commands. +:bind* Bind keys, and define autoloads for the bound commands, + *overriding all minor mode bindings*. +:bind-keymap Bind a key prefix to an auto-loaded keymap defined in the + package. This is like `:bind', but for keymaps. +:bind-keymap* Like `:bind-keymap', but overrides all minor mode bindings + +:defer Defer loading of a package -- this is implied when using + `:commands', `:bind', `:bind*', `:mode', `:magic', `:hook', + `:magic-fallback', or `:interpreter'. This can be an integer, + to force loading after N seconds of idle time, if the package + has not already been loaded. +:demand Prevent the automatic deferred loading introduced by constructs + such as `:bind' (see `:defer' for the complete list). + +:after Delay the effect of the use-package declaration + until after the named libraries have loaded. + Before they have been loaded, no other keyword + has any effect at all, and once they have been + loaded it is as if `:after' was not specified. + +:if EXPR Initialize and load only if EXPR evaluates to a non-nil value. +:disabled The package is ignored completely if this keyword is present. +:defines Declare certain variables to silence the byte-compiler. +:functions Declare certain functions to silence the byte-compiler. +:load-path Add to the `load-path' before attempting to load the package. +:diminish Support for diminish.el (if installed). +:delight Support for delight.el (if installed). +:custom Call `customize-set-variable' on each variable + definition without modifying the Emacs `custom-file'. + (compare with `custom-set-variables'). +:custom-face Call `face-spec-set' with each face definition. +:ensure Loads the package using package.el if necessary. +:pin Pin the package to an archive. +:vc Install the package directly from a version control system + (using `package-vc.el'). + +(fn NAME &rest ARGS)" nil t) (function-put 'use-package 'lisp-indent-function 'defun) (register-definition-prefixes "use-package-core" '("use-package-")) (autoload 'use-package-normalize/:delight "use-package-delight" "Normalize arguments to delight. + +(fn NAME KEYWORD ARGS)") (autoload 'use-package-handler/:delight "use-package-delight" " + +(fn NAME KEYWORD ARGS REST STATE)") (register-definition-prefixes "use-package-delight" '("use-package-normalize-delight")) (autoload 'use-package-normalize/:diminish "use-package-diminish" " + +(fn NAME KEYWORD ARGS)") (autoload 'use-package-handler/:diminish "use-package-diminish" " + +(fn NAME KEYWORD ARG REST STATE)") (register-definition-prefixes "use-package-diminish" '("use-package-normalize-diminish")) (autoload 'use-package-normalize/:ensure "use-package-ensure" " + +(fn NAME KEYWORD ARGS)") (autoload 'use-package-handler/:ensure "use-package-ensure" " + +(fn NAME KEYWORD ENSURE REST STATE)") (register-definition-prefixes "use-package-ensure" '("use-package-")) (autoload 'use-package-normalize/:ensure-system-package "use-package-ensure-system-package" "Turn ARGS into a list of conses of the form (PACKAGE-NAME . INSTALL-COMMAND). + +(fn NAME-SYMBOL KEYWORD ARGS)") (autoload 'use-package-handler/:ensure-system-package "use-package-ensure-system-package" "Execute the handler for `:ensure-system-package' keyword in `use-package'. + +(fn NAME KEYWORD ARG REST STATE)") (register-definition-prefixes "use-package-ensure-system-package" '("use-package-ensure-system-package-")) (autoload 'use-package-jump-to-package-form "use-package-jump" "Attempt to find and jump to the `use-package' form that loaded PACKAGE. +This will only find the form if that form actually required +PACKAGE. If PACKAGE was previously required then this function +will jump to the file that originally required PACKAGE instead. + +(fn PACKAGE)" t) (register-definition-prefixes "use-package-jump" '("use-package-find-require")) (autoload 'use-package-lint "use-package-lint" "Check for errors in `use-package' declarations. +For example, if the module's `:if' condition is met, but even +with the specified `:load-path' the module cannot be found." t) (register-definition-prefixes "use-package-lint" '("use-package-lint-declaration")) (provide 'use-package-autoloads)) "diminish" ((diminish-autoloads diminish diminish-pkg) (autoload 'diminish "diminish" "Diminish mode-line display of minor mode MODE to TO-WHAT (default \"\"). + +Interactively, enter (with completion) the name of any minor mode, followed +on the next line by what you want it diminished to (default empty string). +The response to neither prompt should be quoted. However, in Lisp code, +both args must be quoted, the first as a symbol, the second as a string, +as in (diminish \\='jiggle-mode \" Jgl\"). + +The mode-line displays of minor modes usually begin with a space, so +the modes' names appear as separate words on the mode line. However, if +you're having problems with a cramped mode line, you may choose to use single +letters for some modes, without leading spaces. Capitalizing them works +best; if you then diminish some mode to \"X\" but have `abbrev-mode' enabled as +well, you'll get a display like \"AbbrevX\". This function prepends a space +to TO-WHAT if it's > 1 char long & doesn't already begin with a space. + +(fn MODE &optional TO-WHAT)" t) (autoload 'diminish-undo "diminish" "Restore mode-line display of diminished mode MODE to its minor-mode value. +Do nothing if the arg is a minor mode that hasn't been diminished. + +Interactively, enter (with completion) the name of any diminished mode (a +mode that was formerly a minor mode on which you invoked \\[diminish]). +To restore all diminished modes to minor status, answer `diminished-modes'. +The response to the prompt shouldn't be quoted. However, in Lisp code, +the arg must be quoted as a symbol, as in (diminish-undo \\='diminished-modes). + +(fn MODE)" t) (autoload 'diminished-modes "diminish" "Echo all active diminished or minor modes as if they were minor. +The display goes in the echo area; if it's too long even for that, +you can see the whole thing in the *Messages* buffer. +This doesn't change the status of any modes; it just lets you see +what diminished modes would be on the mode-line if they were still minor." t) (register-definition-prefixes "diminish" '("diminish")) (provide 'diminish-autoloads)) "goto-chg" ((goto-chg-autoloads goto-chg) (autoload 'goto-last-change "goto-chg" "Go to the point where the last edit was made in the current buffer. +Repeat the command to go to the second last edit, etc. + +To go back to more recent edit, the reverse of this command, use \\[goto-last-change-reverse] +or precede this command with \\[universal-argument] - (minus). + +It does not go to the same point twice even if there has been many edits +there. I call the minimal distance between distinguishable edits \"span\". +Set variable `glc-default-span' to control how close is \"the same point\". +Default span is 8. +The span can be changed temporarily with \\[universal-argument] right before \\[goto-last-change]: +\\[universal-argument] <NUMBER> set current span to that number, +\\[universal-argument] (no number) multiplies span by 4, starting with default. +The so set span remains until it is changed again with \\[universal-argument], or the consecutive +repetition of this command is ended by any other command. + +When span is zero (i.e. \\[universal-argument] 0) subsequent \\[goto-last-change] visits each and +every point of edit and a message shows what change was made there. +In this case it may go to the same point twice. + +This command uses undo information. If undo is disabled, so is this command. +At times, when undo information becomes too large, the oldest information is +discarded. See variable `undo-limit'. + +(fn ARG)" t) (autoload 'goto-last-change-reverse "goto-chg" "Go back to more recent changes after \\[goto-last-change] have been used. +See `goto-last-change' for use of prefix argument. + +(fn ARG)" t) (register-definition-prefixes "goto-chg" '("glc-")) (provide 'goto-chg-autoloads)) "evil" ((evil-autoloads evil evil-vars evil-types evil-test-helpers evil-states evil-search evil-repeat evil-maps evil-macros evil-keybindings evil-jumps evil-integration evil-ex evil-digraphs evil-development evil-core evil-common evil-commands evil-command-window) (register-definition-prefixes "evil-command-window" '("evil-")) (register-definition-prefixes "evil-commands" '("evil-")) (register-definition-prefixes "evil-common" '("bounds-of-evil-" "evil-" "forward-evil-")) (autoload 'evil-mode "evil" nil t) (register-definition-prefixes "evil-core" '("evil-" "turn-o")) (autoload 'evil-digraph "evil-digraphs" "Convert DIGRAPH to character or list representation. +If DIGRAPH is a list (CHAR1 CHAR2), return the corresponding character; +if DIGRAPH is a character, return the corresponding list. +Searches in `evil-digraphs-table-user' and `evil-digraphs-table'. + +(fn DIGRAPH)") (register-definition-prefixes "evil-digraphs" '("evil-digraphs-table")) (register-definition-prefixes "evil-ex" '("evil-")) (register-definition-prefixes "evil-integration" '("evil-")) (register-definition-prefixes "evil-jumps" '("evil-")) (register-definition-prefixes "evil-keybindings" '("evil--set-motion-state")) (register-definition-prefixes "evil-macros" '("evil-")) (register-definition-prefixes "evil-maps" '("evil-")) (register-definition-prefixes "evil-repeat" '("evil-")) (register-definition-prefixes "evil-search" '("evil-")) (register-definition-prefixes "evil-states" '("evil-")) (register-definition-prefixes "evil-test-helpers" '("evil-")) (register-definition-prefixes "evil-types" '("evil-ex-get-optional-register-and-count")) (register-definition-prefixes "evil-vars" '("evil-")) (provide 'evil-autoloads)) "annalist" ((annalist-autoloads annalist) (autoload 'annalist-record "annalist" "In the store for ANNALIST, TYPE, and LOCAL, record RECORD. +ANNALIST should correspond to the package/user recording this information (e.g. +'general, 'me, etc.). TYPE is the type of information being recorded (e.g. +'keybindings). LOCAL corresponds to whether to store RECORD only for the current +buffer. This information together is used to select where RECORD should be +stored in and later retrieved from with `annalist-describe'. RECORD should be a +list of items to record and later print as org headings and column entries in a +single row. If PLIST is non-nil, RECORD should be a plist instead of an ordered +list (e.g. '(keymap org-mode-map key \"C-c a\" ...)). The plist keys should be +the symbols used for the definition of TYPE. + +(fn ANNALIST TYPE RECORD &key LOCAL PLIST)") (autoload 'annalist-describe "annalist" "Describe information recorded by ANNALIST for TYPE. +For example: (annalist-describe 'general 'keybindings) If VIEW is non-nil, use +those settings for displaying recorded information instead of the defaults. + +(fn ANNALIST TYPE &optional VIEW)") (register-definition-prefixes "annalist" '("annalist-")) (provide 'annalist-autoloads)) "evil-collection" ((evil-collection-autoloads evil-collection) (autoload 'evil-collection-translate-minor-mode-key "evil-collection" "Translate keys in the keymap(s) corresponding to STATES and MODES. + +Similar to `evil-collection-translate-key' but for minor modes. +STATES should be the name of an evil state, a list of states, or nil. MODES +should be a symbol corresponding to minor-mode to make the translations in or a +list of minor-mode symbols. TRANSLATIONS corresponds to a list of +key replacement pairs. For example, specifying \"a\" \"b\" will bind \"a\" to +\"b\"'s definition in the keymap. Specifying nil as a replacement will unbind a +key. If DESTRUCTIVE is nil, a backup of the keymap will be stored on the initial +invocation, and future invocations will always look up keys in the backup +keymap. When no TRANSLATIONS are given, this function will only create the +backup keymap without making any translations. On the other hand, if DESTRUCTIVE +is non-nil, the keymap will be destructively altered without creating a backup. +For example, calling this function multiple times with \"a\" \"b\" \"b\" \"a\" +would continue to swap and unswap the definitions of these keys. This means that +when DESTRUCTIVE is non-nil, all related swaps/cycles should be done in the same +invocation. + +(fn STATES MODES &rest TRANSLATIONS &key DESTRUCTIVE &allow-other-keys)") (function-put 'evil-collection-translate-minor-mode-key 'lisp-indent-function 'defun) (autoload 'evil-collection-translate-key "evil-collection" "Translate keys in the keymap(s) corresponding to STATES and KEYMAPS. +STATES should be the name of an evil state, a list of states, or nil. KEYMAPS +should be a symbol corresponding to the keymap to make the translations in or a +list of keymap symbols. Like `evil-define-key', when a keymap does not exist, +the keybindings will be deferred until the keymap is defined, so +`with-eval-after-load' is not necessary. TRANSLATIONS corresponds to a list of +key replacement pairs. For example, specifying \"a\" \"b\" will bind \"a\" to +\"b\"'s definition in the keymap. Specifying nil as a replacement will unbind a +key. If DESTRUCTIVE is nil, a backup of the keymap will be stored on the initial +invocation, and future invocations will always look up keys in the backup +keymap. When no TRANSLATIONS are given, this function will only create the +backup keymap without making any translations. On the other hand, if DESTRUCTIVE +is non-nil, the keymap will be destructively altered without creating a backup. +For example, calling this function multiple times with \"a\" \"b\" \"b\" \"a\" +would continue to swap and unswap the definitions of these keys. This means that +when DESTRUCTIVE is non-nil, all related swaps/cycles should be done in the same +invocation. + +(fn STATES KEYMAPS &rest TRANSLATIONS &key DESTRUCTIVE &allow-other-keys)") (function-put 'evil-collection-translate-key 'lisp-indent-function 'defun) (autoload 'evil-collection-swap-key "evil-collection" "Wrapper around `evil-collection-translate-key' for swapping keys. +STATES, KEYMAPS, and ARGS are passed to `evil-collection-translate-key'. ARGS +should consist of key swaps (e.g. \"a\" \"b\" is equivalent to \"a\" \"b\" \"b\" +\"a\" with `evil-collection-translate-key') and optionally keyword arguments for +`evil-collection-translate-key'. + +(fn STATES KEYMAPS &rest ARGS)" nil t) (function-put 'evil-collection-swap-key 'lisp-indent-function 'defun) (autoload 'evil-collection-swap-minor-mode-key "evil-collection" "Wrapper around `evil-collection-translate-minor-mode-key' for swapping keys. +STATES, MODES, and ARGS are passed to +`evil-collection-translate-minor-mode-key'. ARGS should consist of key swaps +(e.g. \"a\" \"b\" is equivalent to \"a\" \"b\" \"b\" \"a\" +with `evil-collection-translate-minor-mode-key') and optionally keyword +arguments for `evil-collection-translate-minor-mode-key'. + +(fn STATES MODES &rest ARGS)" nil t) (function-put 'evil-collection-swap-minor-mode-key 'lisp-indent-function 'defun) (autoload 'evil-collection-require "evil-collection" "Require the evil-collection-MODE file, but do not activate it. + +MODE should be a symbol. This requires the evil-collection-MODE +feature without needing to manipulate `load-path'. NOERROR is +forwarded to `require'. + +(fn MODE &optional NOERROR)") (autoload 'evil-collection-init "evil-collection" "Register the Evil bindings for all modes in `evil-collection-mode-list'. + +Alternatively, you may register select bindings manually, for +instance: + + (with-eval-after-load ='calendar + (evil-collection-calendar-setup)) + +If MODES is specified (as either one mode or a list of modes), use those modes +instead of the modes in `evil-collection-mode-list'. + +(fn &optional MODES)" t) (register-definition-prefixes "evil-collection" '("evil-collection-")) (provide 'evil-collection-autoloads)) "ultra-scroll" ((ultra-scroll-autoloads ultra-scroll) (defvar ultra-scroll-mode nil "Non-nil if Ultra-Scroll mode is enabled. +See the `ultra-scroll-mode' command +for a description of this minor mode. +Setting this variable directly does not take effect; +either customize it (see the info node `Easy Customization') +or call the function `ultra-scroll-mode'.") (custom-autoload 'ultra-scroll-mode "ultra-scroll" nil) (autoload 'ultra-scroll-mode "ultra-scroll" "Toggle pixel precision scrolling. + +When enabled, this minor mode scrolls the display precisely using +full trackpad or modern mouse capabilities. It correctly scrolls +past images taller than the window height. The mode enables +`pixel-scroll-precision-mode-map', overriding that mode's scroll +command, but other mode features, including interpolated page +scrolling, still function (if enabled). + +Note that `ultra-scroll' does NOT do any interpolation of scroll +wheel data, and is intended for use with mouse/trackpad hardware +on systems providing pixel-level scroll data; see +`ultra-scroll-check' to investigate what kind of scrolling data +your system and hardware provide. + +This is a global minor mode. If called interactively, toggle the +`Ultra-Scroll mode' mode. If the prefix argument is positive, enable +the mode, and if it is zero or negative, disable the mode. + +If called from Lisp, toggle the mode if ARG is `toggle'. Enable the +mode if ARG is nil, omitted, or is a positive number. Disable the mode +if ARG is a negative number. + +To check whether the minor mode is enabled in the current buffer, +evaluate `(default-value \\='ultra-scroll-mode)'. + +The mode's hook is called both when the mode is enabled and when it is +disabled. + +(fn &optional ARG)" t) (register-definition-prefixes "ultra-scroll" '("ultra-scroll")) (provide 'ultra-scroll-autoloads)))) + +#s(hash-table test eq data (org-elpa #s(hash-table test equal data (version (16 "https://github.com/emacs-straight/org-mode.git") "use-package" nil "bind-key" nil "diminish" nil "evil" nil "cl-lib" nil "goto-chg" nil "evil-collection" nil "annalist" nil "ultra-scroll" nil)) melpa #s(hash-table test equal data (version 3 "use-package" nil "bind-key" nil "diminish" nil "evil" nil "cl-lib" nil "goto-chg" nil "evil-collection" nil "annalist" nil "ultra-scroll" nil)) gnu-elpa-mirror #s(hash-table test equal data (version 3 "use-package" (use-package :type git :host github :repo "emacs-straight/use-package" :files ("*" (:exclude ".git"))) "bind-key" (bind-key :type git :host github :repo "emacs-straight/bind-key" :files ("*" (:exclude ".git"))) "diminish" (diminish :type git :host github :repo "emacs-straight/diminish" :files ("*" (:exclude ".git"))) "evil" nil "cl-lib" nil "goto-chg" nil "evil-collection" nil "annalist" nil "ultra-scroll" nil)) nongnu-elpa #s(hash-table test equal data (version (5 "https://github.com/emacsmirror/nongnu_elpa.git") "evil" (evil :repo "https://github.com/emacs-evil/evil" :files (:defaults (:exclude "COPYING" "lib" "scripts"))) "cl-lib" nil "goto-chg" (goto-chg :repo "https://github.com/emacs-evil/goto-chg" :files (:defaults (:exclude "LICENSE"))) "evil-collection" nil "annalist" nil "ultra-scroll" nil)) el-get #s(hash-table test equal data (version 2 "cl-lib" nil "evil-collection" nil "annalist" nil "ultra-scroll" nil)) emacsmirror-mirror #s(hash-table test equal data (version 2 "cl-lib" nil "evil-collection" (evil-collection :type git :host github :repo "emacsmirror/evil-collection") "annalist" (annalist :type git :host github :repo "emacsmirror/annalist") "ultra-scroll" (ultra-scroll :type git :host github :repo "emacsmirror/ultra-scroll"))))) + +("annalist" "evil-collection" "nadvice" "goto-chg" "cl-lib" "evil" "diminish" "bind-key" "use-package" "emacsmirror-mirror" "el-get" "nongnu-elpa" "gnu-elpa-mirror" "melpa" "org-elpa" "emacs" "straight") + +t |