Current File : //usr/local/share/emacs/27.2/lisp/jit-lock.elc
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.
;;; This file uses dynamic docstrings, first added in Emacs 19.29.
;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(byte-code "\300\301\302\303\304\305\306\307&\210\310\311\312\313\314DD\315\316\317\306\301&\210\310\320\312\313\321DD\322\316\323\306\301&\210\310\324\312\313\325DD\326\316\327\306\301&\210\310\330\312\313\331DD\332\316\3331K \334 0\202O \210\202V \203V \335\202W \336\306\301&\210\310\337\312\313\340DD\341\316\342\306\301&\210\343\344\345\"\210\310\345\312\313\346DD\347\316\350\306\301&\210\310\351\312\313\352DD\353\316\354\306\301&\210\310\355\312\313\356DD\357\316\360\306\301\304\361& \210\310\362\312\313\363DD\364\306\301\316\365&\207" [custom-declare-group jit-lock nil "Font Lock support mode to fontify just-in-time." :version "21.1" :group font-lock custom-declare-variable jit-lock-chunk-size funcall function #[0 "\300\207" [500] 1] "Jit-lock fontifies chunks of at most this many characters at a time.\n\nThis variable controls both display-time and stealth fontification." :type integer jit-lock-stealth-time #[0 "\300\207" [nil] 1] "Time in seconds to wait before beginning stealth fontification.\nStealth fontification occurs if there is no input within this time.\nIf nil, stealth fontification is never performed.\n\nThe value of this variable is used when JIT Lock mode is turned on." (choice (const :tag "never" nil) (number :tag "seconds" :value 16)) jit-lock-stealth-nice #[0 "\300\207" [0.5] 1] "Time in seconds to pause between chunks of stealth fontification.\nEach iteration of stealth fontification is separated by this amount of time,\nthus reducing the demand that stealth fontification makes on the system.\nIf nil, means stealth fontification is never paused.\nTo reduce machine load during stealth fontification, at the cost of stealth\ntaking longer to fontify, you could increase the value of this variable.\nSee also `jit-lock-stealth-load'." (choice (const :tag "never" nil) (number :tag "seconds")) jit-lock-stealth-load #[0 "\3001\n \301 0\202
\210\302\207\205 \303\207" [(error) load-average nil 200] 1] "Load in percentage above which stealth fontification is suspended.\nStealth fontification pauses when the system short-term load average (as\nreturned by the function `load-average' if supported) goes above this level,\nthus reducing the demand that stealth fontification makes on the system.\nIf nil, means stealth fontification is never suspended.\nTo reduce machine load during stealth fontification, at the cost of stealth\ntaking longer to fontify, you could reduce the value of this variable.\nSee also `jit-lock-stealth-nice'." (error) load-average (choice (const :tag "never" nil) (integer :tag "load")) (const :format "%t: unsupported\n" nil) jit-lock-stealth-verbose #[0 "\300\207" [nil] 1] "If non-nil, means stealth fontification should show status messages." boolean defvaralias jit-lock-defer-contextually jit-lock-contextually #[0 "\300\207" [syntax-driven] 1] "If non-nil, fontification should be syntactically true.\nIf nil, refontification occurs only on lines that were modified. This\nmeans where modification on a line causes syntactic change on subsequent lines,\nthose subsequent lines are not refontified to reflect their new context.\nIf t, fontification occurs on those lines modified and all subsequent lines.\nThis means those subsequent lines are refontified to reflect their new\nsyntactic context, after `jit-lock-context-time' seconds.\nIf any other value, e.g., `syntax-driven', it means refontification of\nsubsequent lines to reflect their new syntactic context may or may not\noccur after `jit-lock-context-time', depending on the the font-lock\ndefinitions of the buffer. Specifically, if `font-lock-keywords-only'\nis nil in a buffer, which generally means the syntactic fontification\nis done using the buffer mode's syntax table, the syntactic\nrefontification will be triggered (because in that case font-lock\ncalls `jit-lock-register' to set up for syntactic refontification,\nand sets the buffer-local value of `jit-lock-contextually' to t).\n\nThe value of this variable is used when JIT Lock mode is turned on." (choice (const :tag "never" nil) (const :tag "always" t) (other :tag "syntax-driven" syntax-driven)) jit-lock-context-time #[0 "\300\207" [0.5] 1] "Idle time after which text is contextually refontified, if applicable." (number :tag "seconds") jit-lock-antiblink-grace #[0 "\300\207" [2] 1] "Delay after which to refontify unterminated strings and comments.\nIf nil, no grace period is given; unterminated strings and comments\nare refontified immediately. If a number, a newly created\nunterminated string or comment is fontified only to the end of the\ncurrent line, after which fontification waits that many seconds of idle\ntime before refontifying the remaining lines. When typing strings\nand comments, the delay helps avoid unpleasant \"blinking\", between\nstring/comment and non-string/non-comment fontification." (choice (const :tag "never" nil) (number :tag "seconds")) "27.1" jit-lock-defer-time #[0 "\300\207" [nil] 1] "Idle time after which deferred fontification should take place.\nIf nil, fontification is not deferred.\nIf 0, then fontification is only deferred while there is input pending." (choice (const :tag "never" nil) (number :tag "seconds"))] 10)
#@49 Non-nil means Just-in-time Lock mode is active.
(defvar jit-lock-mode nil (#$ . 5603))
(make-variable-buffer-local 'jit-lock-mode)
#@123 Functions to do the actual fontification.
They are called with two arguments: the START and END of the region to fontify.
(defvar jit-lock-functions nil (#$ . 5741))
(make-variable-buffer-local 'jit-lock-functions)
#@110 Consider text after this position as contextually unfontified.
If nil, contextual fontification is disabled.
(defvar jit-lock-context-unfontify-pos nil (#$ . 5963))
(make-variable-buffer-local 'jit-lock-context-unfontify-pos)
#@60 Timer for stealth fontification in Just-in-time Lock mode.
(defvar jit-lock-stealth-timer nil (#$ . 6195))
#@69 Timer for repeated stealth fontification in Just-in-time Lock mode.
(defvar jit-lock-stealth-repeat-timer nil (#$ . 6308))
#@60 Timer for context fontification in Just-in-time Lock mode.
(defvar jit-lock-context-timer nil (#$ . 6437))
#@61 Timer for deferred fontification in Just-in-time Lock mode.
(defvar jit-lock-defer-timer nil (#$ . 6550))
#@54 List of buffers with pending deferred fontification.
(defvar jit-lock-defer-buffers nil (#$ . 6662))
#@54 List of buffers that are being fontified stealthily.
(defvar jit-lock-stealth-buffers nil (#$ . 6769))
#@67 Idle timer for fontifying unterminated string or comment, or nil.
(defvar jit-lock--antiblink-grace-timer nil (#$ . 6878))
#@61 Last line beginning position after last command (a marker).
(defvar jit-lock--antiblink-line-beginning-position (make-marker) (#$ . 7007))
#@65 Non-nil if in string or comment after last command (a boolean).
(defvar jit-lock--antiblink-string-or-comment nil (#$ . 7152))
#@1671 Toggle Just-in-time Lock mode.
Turn Just-in-time Lock mode on if and only if ARG is non-nil.
Enable it automatically by customizing group `font-lock'.
When Just-in-time Lock mode is enabled, fontification is different in the
following ways:
- Demand-driven buffer fontification triggered by Emacs C code.
This means initial fontification of the whole buffer does not occur.
Instead, fontification occurs when necessary, such as when scrolling
through the buffer would otherwise reveal unfontified areas. This is
useful if buffer fontification is too slow for large buffers.
- Stealthy buffer fontification if `jit-lock-stealth-time' is non-nil.
This means remaining unfontified areas of buffers are fontified if Emacs has
been idle for `jit-lock-stealth-time' seconds, while Emacs remains idle.
This is useful if any buffer has any deferred fontification.
- Deferred context fontification if `jit-lock-contextually' is
non-nil. This means fontification updates the buffer corresponding to
true syntactic context, after `jit-lock-context-time' seconds of Emacs
idle time, while Emacs remains idle. Otherwise, fontification occurs
on modified lines only, and subsequent lines can remain fontified
corresponding to previous syntactic contexts. This is useful where
strings or comments span lines.
Stealth fontification only occurs while the system remains unloaded.
If the system load rises above `jit-lock-stealth-load' percent, stealth
fontification is suspended. Stealth fontification intensity is controlled via
the variable `jit-lock-stealth-nice'.
If you need to debug code run from jit-lock, see `jit-lock-debug-mode'.
(fn ARG)
(defalias 'jit-lock-mode #[257 "\211\306 \203 \203 \307\310\311!\207\203~ \312 \210 \203& \n\204& \313 \314\315# \203A \204A \316\314\307\211\211\211\211\211\211\211& \317 \315\320#\210\f\203O
\204O \313\f\314\321# \314=\203r \204c \313!\314\322# \323\324\325\307\314$\210\"\206p d\"\323\326\327\307\314$\210\323\330\331\"\207\n\204\213
\204\213 \203\323 \3322\257 \333 \211\205\254 \211@r\211q\210\203\244 \334\332\314\"\210)A\266\202\202\221 \2620\204\323 \n\203\274 \335\n!\210\307 \203\311 \335 !\210\307
\203\323 \335
!\210\307\336\326\327\314#\210\336\330\331\"\207" [jit-lock-mode jit-lock-stealth-time jit-lock-stealth-timer jit-lock-stealth-repeat-timer jit-lock-defer-time jit-lock-defer-timer buffer-base-buffer nil message "Not enabling jit-lock: it does not work in indirect buffer" jit-lock-refontify run-with-idle-timer t jit-lock-stealth-fontify vector timer-set-function (t) jit-lock-deferred-fontify #[0 "?\205 \301 \207" [jit-lock--antiblink-grace-timer jit-lock-context-fontify] 1] add-hook post-command-hook jit-lock--antiblink-post-command after-change-functions jit-lock-after-change fontification-functions jit-lock-function found buffer-list throw cancel-timer remove-hook jit-lock-contextually jit-lock-context-timer jit-lock-context-time jit-lock-context-unfontify-pos] 11 (#$ . 7287)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313\314\315& \207" [custom-declare-variable jit-lock-debug-mode funcall function #[0 "\300\207" [nil] 1] "Non-nil if Jit-Lock-Debug mode is enabled.\nSee the `jit-lock-debug-mode' command\nfor a description of this minor mode.\nSetting this variable directly does not take effect;\neither customize it (see the info node `Easy Customization')\nor call the function `jit-lock-debug-mode'." :set custom-set-minor-mode :initialize custom-initialize-default :group jit-lock :type boolean] 12)
#@499 Minor mode to help debug code run from jit-lock.
If called interactively, enable Jit-Lock-Debug mode if ARG is
positive, and disable it if ARG is zero or negative. If called from
Lisp, also enable the mode if ARG is omitted or nil, and toggle it if
ARG is `toggle'; disable the mode otherwise.
When this minor mode is enabled, jit-lock runs as little code as possible
during redisplay and moves the rest to a timer, where things
like `debug-on-error' and Edebug can be used.
(fn &optional ARG)
(defalias 'jit-lock-debug-mode #[256 "\302 \303\301\304=\203 \305\301!?\202 \306!\307V\"\210\203\" \310!\210\311 \203, \312\307\313\314#\315\316\305\301!\2038 \317\2029 \320\"\210\321\322!\203c \323\301!\210\302 \203Q \211\302 \232\203c \324\325\326\305\301!\203^ \327\202_ \330#\266\210\331 \210\305\301!\207" [jit-lock-defer-timer jit-lock-debug-mode current-message set-default toggle default-value prefix-numeric-value 0 cancel-timer nil run-with-idle-timer t jit-lock--debug-fontify run-hooks jit-lock-debug-mode-hook jit-lock-debug-mode-on-hook jit-lock-debug-mode-off-hook called-interactively-p any customize-mark-as-set "" message "Jit-Lock-Debug mode %sabled%s" "en" "dis" force-mode-line-update] 7 (#$ . 10858) (byte-code "\206 \301C\207" [current-prefix-arg toggle] 1)])
(defvar jit-lock-debug-mode-hook nil)
(byte-code "\301\302N\204\f \303\301\302\304#\210\305\306\307\310\300!\205 \307\211%\207" [jit-lock-debug-mode-map jit-lock-debug-mode-hook variable-documentation put "Hook run after entering or leaving `jit-lock-debug-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" add-minor-mode jit-lock-debug-mode nil boundp] 6)
(defvar jit-lock--debug-fontifying nil)
#@42 Fontify what was deferred for debugging.
(defalias 'jit-lock--debug-fontify #[0 "?\205v \205v \n?\205v \306\307 \211\203q \211@\310!\203j r\211q\210\306 \311 \306\211 \306 \312\313\314\315\316!\317\"\320$\216e\321\322\"\323=\203\\ \211\324\322\307d$\211\262\325\322\307$\210\326\"\266\324\322\"\211\262\204< \210,\210*A\266\202\202 \210\307\211*\207" [jit-lock--debug-fontifying jit-lock-defer-buffers memory-full inhibit-debugger inhibit-point-motion-hooks buffer-undo-list t nil buffer-live-p buffer-modified-p make-byte-code 0 "\300?\205 \301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 get-text-property fontified defer next-single-property-change put-text-property jit-lock-fontify-now inhibit-read-only inhibit-modification-hooks] 12 (#$ . 12641)])
#@286 Register FUN as a fontification function to be called in this buffer.
FUN will be called with two arguments START and END indicating the region
that needs to be (re)fontified.
If non-nil, CONTEXTUAL means that a contextual fontification would be useful.
(fn FUN &optional CONTEXTUAL)
(defalias 'jit-lock-register #[513 "\301\302\303\304$\210\211\203 \203 \305\300!\210\304\306\304!\207" [jit-lock-contextually add-hook jit-lock-functions nil t make-local-variable jit-lock-mode] 7 (#$ . 13441)])
#@91 Unregister FUN as a fontification function.
Only applies to the current buffer.
(fn FUN)
(defalias 'jit-lock-unregister #[257 "\301\300\302#\210?\205 \303\304!\207" [jit-lock-functions remove-hook t jit-lock-mode nil] 5 (#$ . 13949)])
#@94 Force refontification of the region BEG..END (default whole buffer).
(fn &optional BEG END)
(defalias 'jit-lock-refontify #[512 "\304\305 \304\211\304\306\307\310\311\312!\313\"\314$\216\214~\210\315\206 e\206$ d\316\317$-\262)\207" [inhibit-point-motion-hooks buffer-undo-list inhibit-read-only inhibit-modification-hooks t buffer-modified-p make-byte-code 0 "\300?\205 \301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 put-text-property fontified nil] 10 (#$ . 14194)])
#@148 Fontify current buffer starting at position START.
This function is added to `fontification-functions' when `jit-lock-mode'
is active.
(fn START)
(defalias 'jit-lock-function #[257 "\205W ?\205W \n\203 \306=\203 \307 \204 \310\211\f\\\"\207p
>\204) p
B\311 \312 \311\211 \311 \313\306\314\315\316!\317\"\320$\216\321\322\323\324d\f\\^$\323\325$,\262)\207" [jit-lock-mode memory-full jit-lock-defer-timer jit-lock-defer-time jit-lock-chunk-size jit-lock-defer-buffers 0 input-pending-p jit-lock-fontify-now t buffer-modified-p make-byte-code "\300?\205 \301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 put-text-property next-single-property-change fontified nil defer inhibit-point-motion-hooks buffer-undo-list inhibit-read-only inhibit-modification-hooks] 12 (#$ . 14698)])
#@16
(fn BEG END)
(defalias 'jit-lock--run-functions #[514 "\300C\300CCC\301\302\303\304\305\306\307\f\f\f\f\f\f&\310\"\311\312%\"\210\242^\242]\242\242F\207" [nil run-hook-wrapped jit-lock-functions make-byte-code 257 "\211\300\301\"\211\242\306=\203 \211A\202 \300\301B\211@A\211\302\211\242\206 e]\240\210\303\211\242\206+ d^\240\210\304\211\242^\240\210\305\211\242]\240\210\307\266\202\207" vconcat vector [jit-lock-bounds nil] 10 "\n\n(fn FUN)"] 19 (#$ . 15515)])
#@126 Fontify current buffer from START to END.
Defaults to the whole buffer. END can be out of bounds.
(fn &optional START END)
(defalias 'jit-lock-fontify-now #[512 "\305\306 \305\211\305\307\310\311\312\313!\314\"\315$\216\212\204 e\262\203( d^\202) d\262\316\317 \307\310\320\312\313!\321\"\322$\216\205\352 W\205\352 \323\324\305$\206Q \262V\203\335 \325\324\305$\210\3261o \327\"0\202 \325\324\316$\210\330@A\"\262\211@A\211@A\211@A\211@A\n\211W\204\243 V\203\252 \325\324\305$\210\f\203\303 \fW\203\303 \fY\203\303 \331\332\"\204\303 W\203\330 \333\310\316\334\335!\335!%\210\262\266
\323\324\316$\262\202; )\262\266\202-\262)\207" [inhibit-point-motion-hooks buffer-undo-list inhibit-read-only inhibit-modification-hooks jit-lock-context-unfontify-pos t buffer-modified-p make-byte-code 0 "\300?\205 \301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 nil match-data "\301\300\302\"\207" [set-match-data evaporate] 3 text-property-any fontified put-text-property (quit) jit-lock--run-functions signal get-text-property jit-lock-defer-multiline run-with-timer jit-lock-force-redisplay copy-marker] 27 (#$ . 16015)])
#@146 Force the display engine to re-render START's buffer from START to END.
This applies to the buffer associated with marker START.
(fn START END)
(defalias 'jit-lock-force-redisplay #[514 "\304!\205H r\304!q\210\305\306 \305\211\305\307\310\311\312\313!\314\"\315$\216dV\2030 d\262^\262eW\203> e\262]\262\316\317\305$,\262*\207" [inhibit-point-motion-hooks buffer-undo-list inhibit-read-only inhibit-modification-hooks marker-buffer t buffer-modified-p make-byte-code 0 "\300?\205 \301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 put-text-property fontified] 10 (#$ . 17229)])
#@134 Return the start of the next chunk to fontify around position AROUND.
Value is nil if there is nothing more to fontify.
(fn AROUND)
(defalias 'jit-lock-stealth-chunk-start #[257 "\301 \302U?\205j \303d\304\305$\306\304\"\307eS]\304\"\204. \211\305=?\205H e\310\245Z]\202H \211\305=\203C \306\304\"\206< eZ]\202H Z]\211\204P \202h \204X \211\202h ZZW\203g \211\202h \266\204\207" [jit-lock-chunk-size buffer-size 0 text-property-not-all fontified t previous-single-property-change get-text-property 2] 8 (#$ . 17848)])
(put 'jit-lock-stealth-chunk-start 'byte-optimizer 'byte-compile-inline-expand)
#@241 Fontify buffers stealthily.
This function is called repeatedly after Emacs has become idle for
`jit-lock-stealth-time' seconds. Optional argument REPEAT is expected
non-nil in a repeated invocation of this function.
(fn &optional REPEAT)
(defalias 'jit-lock-stealth-fontify #[256 "\211\204 \306!\210 \206\" \n\206\" \307 \206\" \211\203 \202! \310 \211??\205, @\311\312\211\211 $\203I \313 @\206< \311$V\203I %\262\202\314!\203rq\210&\203\f`\315 \311U?\205\306 \316d\317\320$\321\317\"\322eS]\317\"\204\210 \211\320=?\205\244 e'\323\245Z]\202\244 \211\320=\203\236 \321\317\"\206\226 e'Z]\202\244 'Z]\211\204\254 \202\304 \204\264 \211\202\304 ZZW\203\303 \211\202\304 \266\204\262\211\262\203\f(\205\327 \324\325 P\312C\326\311\327\330\331\"\332\"\333$\216\203\366 \211\334 \240\210\335\336\"\210\337\211'\\\"\210)\206\311\262)\266\202 A)\202 A \205)\340\341 \"\210\342\"\210\343\320\"*\266\205\207" [jit-lock-stealth-repeat-timer executing-kbd-macro memory-full jit-lock-stealth-buffers message-log-max minibuffer-auto-raise cancel-timer window-minibuffer-p buffer-list 0 nil load-average buffer-live-p buffer-size text-property-not-all fontified t previous-single-property-change get-text-property 2 "JIT stealth lock " buffer-name make-byte-code "\300\205 \301\242\203 \302\303\301\242\"\207\302\304!\207" vconcat vector [message "%s" nil] 3 current-message message "%s" jit-lock-fontify-now timer-set-idle-time current-idle-time timer-inc-time timer-activate-when-idle jit-lock-stealth-load jit-lock-stealth-time jit-lock-mode jit-lock-chunk-size jit-lock-stealth-verbose jit-lock-stealth-nice] 15 (#$ . 18474)])
#@28 Fontify what was deferred.
(defalias 'jit-lock-deferred-fontify #[0 "\205q ?\205q \211\203^ \211@\306!\203W r\211q\210\307\310 \307\211 \307 \311\312\313\314\315!\316\"\317$\216e\320\321\"\322=\203I \323\324\321\325d$\211\262\321\325$\210\324\321\"\211\262\2041 \210,\210*A\266\202\202\n \210\325\211 \326 ?\205n \211\211)\262\207" [jit-lock-defer-buffers memory-full inhibit-point-motion-hooks buffer-undo-list inhibit-read-only inhibit-modification-hooks buffer-live-p t buffer-modified-p make-byte-code 0 "\300?\205 \301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 get-text-property fontified defer put-text-property next-single-property-change nil redisplay jit-lock-defer-timer] 12 (#$ . 20171)])
#@57 Refresh fontification to take new context into account.
(defalias 'jit-lock-context-fontify #[0 "?\205` \306 \211\205^ \211@r\211q\210 \203V \214~\210 eY\203U dW\203U \307 \310\"\2034 \311 \310\"\2063 e\312\313 \312\211 \312 \314\315\316\317\320!\321\"\322$\216\323 d\324#\210,\210)d))A\266\202\202 \262\207" [memory-full jit-lock-context-unfontify-pos inhibit-point-motion-hooks buffer-undo-list inhibit-read-only inhibit-modification-hooks buffer-list get-text-property jit-lock-defer-multiline previous-single-property-change t buffer-modified-p make-byte-code 0 "\300?\205 \301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 remove-text-properties (fontified nil jit-lock-defer-multiline nil)] 10 (#$ . 20914)])
#@611 Hook that can extend the text to refontify after a change.
This is run after every buffer change. The functions are called with
the three arguments of `after-change-functions': START END OLD-LEN.
The extended region to refontify is returned indirectly by modifying
the variables `jit-lock-start' and `jit-lock-end'.
Note that extending the region this way is not strictly necessary, except
that the nature of the redisplay code tends to otherwise leave some of
the rehighlighted text displayed with the old highlight until the next
redisplay (see comment about repeated redisplay in `jit-lock-fontify-now').
(defvar jit-lock-after-change-extend-region-functions nil (#$ . 21660))
#@406 Mark the rest of the buffer as not fontified after a change.
Installed on `after-change-functions'.
START and END are the start and end of the changed text. OLD-LEN
is the pre-change length.
This function ensures that lines following the change will be refontified
in case the syntax of those lines has changed. Refontification
will take place when text is fontified stealthily.
(fn START END OLD-LEN)
(defalias 'jit-lock-after-change #[771 "\205M ?\205M \306 \307 \306\211 \306 \310\311\312\313\314!\315\"\316$\216\317\320$\210\nT]d^\214~\210\321 \n\322\323$\210-\210)\205L ^\211*\207" [jit-lock-mode memory-full jit-lock-end jit-lock-start inhibit-point-motion-hooks buffer-undo-list t buffer-modified-p make-byte-code 0 "\300?\205 \301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 run-hook-with-args jit-lock-after-change-extend-region-functions put-text-property fontified nil inhibit-read-only inhibit-modification-hooks jit-lock-context-unfontify-pos] 11 (#$ . 22349)])
(defalias 'jit-lock--antiblink-post-command #[0 "\304\305 !\305\306!\205 U?\205 \307 !p=\205 U\211\205( \310\212\311!)8\203= \n\204= \211\203= \312\313\314#\202g \203V \211\204V \n\203V \203g \315 !\210\313\202g \204g \203g \316 \210\315 !\210\313 \313\211\223\210\211\211\207" [jit-lock-antiblink-grace jit-lock--antiblink-line-beginning-position jit-lock--antiblink-string-or-comment jit-lock--antiblink-grace-timer copy-marker line-beginning-position 2 marker-buffer 8 syntax-ppss run-with-idle-timer nil #[0 "\301 \210\302\211\207" [jit-lock--antiblink-grace-timer jit-lock-context-fontify nil] 2] cancel-timer jit-lock-context-fontify] 8])
(provide 'jit-lock)
Mini Shell