;ELC   
;;; Compiled
;;; in Emacs version 29.4
;;; with all optimizations.


(byte-code "\300\301!\210\300\302!\210\303\304\305\306\307\310\311\312&\207" [require treesit ruby-mode custom-declare-group ruby-ts nil "Major mode for editing Ruby code." :prefix "ruby-ts-" :group languages] 8)#@46 Ruby operators for tree-sitter font-locking.
(defvar ruby-ts--operators '("+" "-" "*" "/" "%" "**" "==" "!=" ">" "<" ">=" "<=" "<=>" "===" "=" "+=" "-=" "*=" "/=" "%=" "**=" "&" "|" "^" "~" "<<" ">>" "!" "&&" "and" "not" "or" "||" "?" ":" ".." "..." "defined?" "." "::") (#$ . 297))#@32 Ruby's punctuation characters.
(defvar ruby-ts--delimiters '("," ";") (#$ . 585))#@35 Ruby predefined global constants.
(defvar ruby-ts--predefined-constants "\\`\\(?:ARG[FV]\\|DATA\\|ENV\\|RUBY_\\(?:COPYRIGHT\\|DESCRIPTION\\|ENGINE\\(?:_VERSION\\)?\\|P\\(?:ATCHLEVEL\\|LATFORM\\)\\|RE\\(?:LEASE_DATE\\|VISION\\)\\|VERSION\\)\\|STD\\(?:ERR\\|IN\\|OUT\\)\\|TOPLEVEL_BINDING\\)\\'" (#$ . 672))#@35 Ruby predefined global variables.
(defvar ruby-ts--predefined-variables "\\`\\(?:\\$\\(?:-[ailp]\\|DEBUG\\|FILENAME\\|LOAD\\(?:ED_FEATURES\\|_PATH\\)\\|VERBOSE\\|std\\(?:err\\|in\\|out\\)\\|[!$&'*+,.-@\\_`~]\\)\\)\\'" (#$ . 983))#@24 Ruby built-in methods.
(defvar ruby-ts--builtin-methods (byte-code "\302\303\304\305	\"!\"\207" [ruby-builtin-methods-no-reqs ruby-builtin-methods-with-reqs format "\\`%s\\'" regexp-opt append] 6) (#$ . 1218))#@64 Regular expression that matches a class or module's node type.
(defconst ruby-ts--class-or-module-regex "\\`\\(?:class\\|module\\|singleton_class\\)\\'" (#$ . 1434))#@60 Regular expression matching methods and singleton methods.
(defconst ruby-ts--method-regex "\\`\\(?:\\(?:singleton_\\)?method\\)\\'" (#$ . 1605))#@62 Regular expression of the nodes that can contain statements.
(defconst ruby-ts--statement-container-regexp "\\`\\(?:b\\(?:egin_block\\|lock_body\\|ody_statement\\)\\|do\\|e\\(?:lse\\|n\\(?:d_block\\|sure\\)\\)\\|interpolation\\|program\\|then\\)\\'" (#$ . 1756))#@48 Return line number of NODE's start.

(fn NODE)
(defalias 'ruby-ts--lineno #[257 "\300\301!!\207" [line-number-at-pos treesit-node-start] 4 (#$ . 2024)])#@45 Ruby keywords for tree-sitter font-locking.
(defvar ruby-ts--keywords '("BEGIN" "END" "alias" "and" "begin" "break" "case" "class" "def" "defined?" "do" "else" "elsif" "end" "ensure" "for" "if" "in" "module" "next" "not" "or" "redo" "rescue" "retry" "return" "then" "undef" "unless" "until" "when" "while" "yield") (#$ . 2183))#@227 Apply font lock to comment NODE within START and END.
Applies `font-lock-comment-delimiter-face' and
`font-lock-comment-face'.  See `treesit-fontify-with-override' for
values of OVERRIDE.

(fn NODE OVERRIDE START END &rest _)
(defalias 'ruby-ts--comment-font-lock #[1156 "\302!\211T\303!\304\305\"Y\2032 X\2032 \306\307\310\305$\266\203\2032 \311$\210\311]^	$\207" [font-lock-comment-delimiter-face font-lock-comment-face treesit-node-start treesit-node-end treesit-node-text t "\\`#" nil string-match treesit-fontify-with-override] 17 (#$ . 2517)])#@57 Tree-sitter font-lock settings for Ruby.

(fn LANGUAGE)
(defalias 'ruby-ts--font-lock-settings #[257 "\306\307\310\311\312\307\310\313\314\315\316\317BBE\320B\307\f\310\321\322\315\316	\323BBE\324B\307\310\325\326\n!\327B\307\310\330\331\307\310\332\333\307 \310\334\335\307%\310\336\337\340\326!\341BBB\307*\310\342\343\307/\310\342\344\3074\310\345\346\3079\310\347\350\307>\310\351\352\307C\310\353\354\307H\310\355\356\307M\310\357\360\307R\310\361\362\316\f\363BBDC\307W\310\364\365\307\\\310\366\367\307a\310\370\371\307f\310\372\373\310\374\307m\375\376\377\307r\310\201@ \201A \307w\310\201B \326!\201C BC&z\207" [ruby-ts--predefined-variables ruby-ts--predefined-constants ruby-ts--keywords ruby-ts--operators ruby-ts--builtin-methods ruby-ts--delimiters treesit-font-lock-rules :language :feature comment ((comment) @ruby-ts--comment-font-lock) builtin-variable (global_variable) @var :match (@var) (@font-lock-builtin-face) builtin-constant (constant) (@var) (@font-lock-builtin-face) keyword vconcat (@font-lock-keyword-face (self) @font-lock-keyword-face (super) @font-lock-keyword-face) constant ((true) @font-lock-constant-face (false) @font-lock-constant-face (nil) @font-lock-constant-face) literal ((unary ["+" "-"] [(integer) (rational) (float) (complex)]) @font-lock-number-face (integer) @font-lock-number-face (float) @font-lock-number-face (complex) @font-lock-number-face (rational) @font-lock-number-face) regexp ((regex "/" @font-lock-regexp-face) (regex _ (string_content) @font-lock-regexp-face)) operator "!" @font-lock-negation-char-face (@font-lock-operator-face) string ((delimited_symbol [":\"" "\""] @font-lock-string-face) (string "\"" @font-lock-string-face) (string_array ["%w(" ")"] @font-lock-string-face) (subshell "`" @font-lock-string-face) (symbol_array ["%i(" ")"] @font-lock-constant-face)) ([(string_content) (heredoc_beginning) (heredoc_content) (heredoc_end)] @font-lock-string-face) interpolation ((interpolation "#{" @font-lock-misc-punctuation-face) (interpolation "}" @font-lock-misc-punctuation-face)) type ((constant) @font-lock-type-face) global ((global_variable) @font-lock-variable-use-face) instance ((instance_variable) @font-lock-variable-use-face) method-definition ((method name: (identifier) @font-lock-function-name-face) (singleton_method name: (identifier) @font-lock-function-name-face) (method name: (setter) @font-lock-function-name-face)) parameter-definition ((method_parameters (identifier) @font-lock-variable-name-face) (block_parameters (identifier) @font-lock-variable-name-face) (optional_parameter name: (identifier) @font-lock-variable-name-face) (splat_parameter name: (identifier) @font-lock-variable-name-face) (hash_splat_parameter name: (identifier) @font-lock-variable-name-face) (block_parameter name: (identifier) @font-lock-variable-name-face) (destructured_parameter (identifier) @font-lock-variable-name-face) (lambda_parameters (identifier) @font-lock-variable-name-face) (exception_variable (identifier) @font-lock-variable-name-face) (array_pattern (identifier) @font-lock-variable-name-face) (keyword_pattern value: (identifier) @font-lock-variable-name-face) (keyword_pattern key: (hash_key_symbol) @font-lock-variable-name-face !value) (as_pattern name: (identifier) @font-lock-variable-name-face) (in_clause pattern: (identifier) @font-lock-variable-name-face)) builtin-function ((identifier) @font-lock-builtin-face) (@font-lock-builtin-face) function ((call method: (identifier) @font-lock-function-call-face)) assignment ((assignment left: (identifier) @font-lock-variable-name-face) (assignment left: (left_assignment_list (identifier) @font-lock-variable-name-face)) (operator_assignment left: (identifier) @font-lock-variable-name-face)) symbol ((bare_symbol) @font-lock-constant-face (delimited_symbol (string_content) @font-lock-constant-face) (hash_key_symbol) @font-lock-constant-face (simple_symbol) @font-lock-constant-face) error ((ERROR) @font-lock-warning-face) escape-sequence :override t ((escape_sequence) @font-lock-escape-face) bracket ((["(" ")" "[" "]" "{" "}"]) @font-lock-bracket-face) punctuation (@font-lock-delimiter-face)] 125 (#$ . 3100)])#@72 Return the first named child of NODE that is not a comment.

(fn NODE)
(defalias 'ruby-ts--first-non-comment-child #[257 "\300\301\302#\211\203 \303!\304\232\203 \305\302\"\262\202 \207" [treesit-node-child 0 t treesit-node-type "comment" treesit-node-next-sibling] 5 (#$ . 7303)])#@95 Return predicate taking a node returning non-nil if REGEXP matches type of node.

(fn REGEXP)
(defalias 'ruby-ts--type-pred #[257 "\300\301\"\207" [make-closure #[257 "\300\301!\302\303\304$\207" [V0 treesit-node-type nil string-match t] 9 "\n\n(fn NODE)"]] 4 (#$ . 7597)])#@68 Return the PARENT node matching ident rule.

(fn N PARENT &rest _)
(defalias 'ruby-ts--parent-node #[642 "\207" [] 4 (#$ . 7881)])#@246 Return either start or bol of PRED.
PRED should specify a node that is listed in
`ruby-alignable-keywords'.  If PRED is listed in user option
`ruby-align-to-stmt-keywords', then return the BOL of PRED.
Otherwise return start of PRED.

(fn PRED)
(defalias 'ruby-ts--align-keywords #[257 "\300\301\"\207" [make-closure #[899 "\300$\301!\302!\303\304\232\203 \305\202 !\205, \211\203+ \212b\210\306 \210`)\207\207" [V0 treesit-node-start treesit-node-type ruby-smie--indent-to-stmt-p "method" "def" back-to-indentation] 10 "\n\n(fn NODE PARENT BOL &rest REST)"]] 4 (#$ . 8019)])#@150 Return bol of PRED.
PRED should take (node parent bol &rest rest) and return a node.
Returns bol of the current line if PRED returns nil.

(fn PRED)
(defalias 'ruby-ts--bol #[257 "\300\301\"\207" [make-closure #[899 "\212\301\300$!\211\203 \211b\210\302 \210`)\207" [V0 treesit-node-start back-to-indentation] 10 "\n\n(fn NODE PARENT BOL &rest REST)"]] 4 (#$ . 8615)])#@54 Return parent of PARENT node.

(fn N PARENT &rest _)
(defalias 'ruby-ts--grand-parent-node #[642 "\300!\207" [treesit-node-parent] 5 (#$ . 8995)])#@59 Return value of `ruby-align-chained-calls'.

(fn &rest _)
(defalias 'ruby-ts--align-chain-p #[128 "\207" [ruby-align-chained-calls] 2 (#$ . 9148)])#@71 Return value of `ruby-parenless-call-arguments-indent'.

(fn &rest _)
(defalias 'ruby-ts--parenless-call-arguments-indent-p #[128 "\207" [ruby-parenless-call-arguments-indent] 2 (#$ . 9302)])#@278 Align chained method call.
Align NODE which will be the dot (.) to the dot of the
first (outermost) call in the chain.  See
`ruby-align-chained-calls' for details.  PARENT will be the
"call" node.  Called only when `ruby-align-chained-calls' is
non-nil.

(fn N PARENT &rest _)
(defalias 'ruby-ts--align-chain #[642 "\300\203 \301!\211\262\203 \302!\303\232\203 \211\262\202 \304\305\306\300\307$!\207" [nil treesit-node-parent treesit-node-type "call" treesit-node-start treesit-search-subtree "\\." t] 10 (#$ . 9501)])#@154 Return non-nil when first argument is on the same line as the method.
PARENT will be argument_list.  NODE can be the close paren.

(fn N PARENT &rest _)
(defalias 'ruby-ts--same-line-args-p #[642 "\300!\301!\302!\302!U\207" [treesit-node-parent ruby-ts--first-non-comment-child ruby-ts--lineno] 8 (#$ . 10037)])#@159 Return non-nil when first parameter is on the same line as the method.
PARENT will be method_parameters.  NODE can be the close paren.

(fn N PARENT &rest _)
(defalias 'ruby-ts--same-line-params-p #[642 "\300!\301!\302!\302!U\207" [treesit-node-parent ruby-ts--first-non-comment-child ruby-ts--lineno] 8 (#$ . 10359)])#@385 Indent parameters that start on next line.
Given: NODE is the parameter.  PARENT is
method_parameters.  `ruby-ts--same-line-params-p' is nil.
Indent according to `ruby-method-params-indent'.

If `ruby-method-params-indent' is 0
def foo(
  param1,
  param2
)

Params start on next line, `ruby-method-params-indent' is t
def foo(
      param1,
      param2
    )

(fn N PARENT &rest _)
(defalias 'ruby-ts--param-indent #[642 "\301!\302=\203 \303!\304\232\305\203 \306\202 \307\"\310!\207\310!\206& \311\\\207" [ruby-method-params-indent treesit-node-parent t treesit-node-type "singleton_method" treesit-node-child-by-field-name "object" "name" treesit-node-start 0] 8 (#$ . 10688)])#@70 I have no idea why I can't just put t but I can put 0.

(fn &rest _)
(defalias 'ruby-ts--true #[128 "\300\207" [t] 2 (#$ . 11386)])#@172 Return non-nil if first element and open brace are on the same line.
NODE is the element or closing brace or bracket.  PARENT is the
array or hash.

(fn N PARENT &rest _)
(defalias 'ruby-ts--same-line-hash-array-p #[642 "\300\301\302#\303!\304!\304!U\207" [treesit-node-child 0 nil ruby-ts--first-non-comment-child ruby-ts--lineno] 8 (#$ . 11524)])#@215 Return the statement ancestor of NODE if any.
A statement is defined as a child of a statement container where
a statement container is a node that matches
`ruby-ts--statement-container-regexp'.

(fn NODE &rest _)
(defalias 'ruby-ts--statement-ancestor #[385 "\301!\211\203' \203' \302!\303\304\305$\266\203\204' \211\262\301!\262\202 \207" [ruby-ts--statement-container-regexp treesit-node-parent treesit-node-type nil string-match t] 12 (#$ . 11883)])#@43 Indent rules supported by `ruby-ts-mode'.
(defalias 'ruby-ts--indent-rules #[0 "\302\303\304\305\306\307\310\311\312\313D\314BBE\315B\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342	E\343B\344\345\346	F\347B\350\341\346	E\351B\344\352\346	F\353B\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377\201@ \201A \201B \201C \201D \201E \201F \201G \201H \201I \201J \201K \344	\346F\201L B\341\342E\201M B\201N BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\201O BC\207" [ruby-ts--class-or-module-regex ruby-ts--method-regex ((parent-is "program") column-0 0) ((n-p-gp nil nil "heredoc_body") no-indent 0) ((parent-is "heredoc_body") no-indent 0) ((node-is "heredoc_body") no-indent 0) ((n-p-gp nil nil "regex") no-indent 0) ((parent-is "regex") no-indent 0) and (parent-is "ERROR") or node-is ((node-is "\\`\\(?:def\\|identifier\\)\\'")) (no-indent 0) ((match "else" "if\\|unless") (ruby-ts--align-keywords ruby-ts--parent-node) 0) ((match "elsif" "if") (ruby-ts--align-keywords ruby-ts--parent-node) 0) ((match "end" "if\\|unless") (ruby-ts--align-keywords ruby-ts--parent-node) 0) ((n-p-gp nil "then\\|else\\|elsif" "if\\|unless") (ruby-ts--align-keywords ruby-ts--grand-parent-node) ruby-indent-level) ((match "when" "case") (ruby-ts--align-keywords ruby-ts--parent-node) 0) ((match "in_clause" "case") (ruby-ts--align-keywords ruby-ts--parent-node) 0) ((match "else" "case") (ruby-ts--align-keywords ruby-ts--parent-node) 0) ((match "end" "case") (ruby-ts--align-keywords ruby-ts--parent-node) 0) ((n-p-gp nil "then" "when") grand-parent ruby-indent-level) ((n-p-gp nil "then" "in_clause") grand-parent ruby-indent-level) ((n-p-gp nil "else" "case") parent ruby-indent-level) ((n-p-gp "end" "do" "while\\|until") (ruby-ts--align-keywords ruby-ts--grand-parent-node) 0) ((n-p-gp nil "do" "while\\|until") (ruby-ts--align-keywords ruby-ts--grand-parent-node) ruby-indent-level) ((n-p-gp nil "then" "rescue") (ruby-ts--align-keywords ruby-ts--grand-parent-node) ruby-indent-level) ((n-p-gp nil "ensure\\|else" "begin") (ruby-ts--align-keywords ruby-ts--parent-node) ruby-indent-level) ((match "rescue\\|ensure\\|else\\|end" "begin") (ruby-ts--align-keywords ruby-ts--parent-node) 0) ((parent-is "begin") (ruby-ts--align-keywords ruby-ts--parent-node) ruby-indent-level) ((n-p-gp "end" "do" "for") (ruby-ts--align-keywords ruby-ts--grand-parent-node) 0) ((n-p-gp nil "do" "for") (ruby-ts--align-keywords ruby-ts--grand-parent-node) ruby-indent-level) match "end" ((ruby-ts--align-keywords ruby-ts--parent-node) 0) n-p-gp "\\`\\(rescue\\|ensure\\|else\\)\\'" "body_statement" ((ruby-ts--align-keywords ruby-ts--grand-parent-node) 0) ((n-p-gp nil "rescue\\|ensure\\|else" "body_statement") parent ruby-indent-level) ((ruby-ts--align-keywords ruby-ts--parent-node) ruby-indent-level) nil ((ruby-ts--align-keywords ruby-ts--grand-parent-node) ruby-indent-level) ((match "\\`\\'" "\\`\\(?:if\\|unless\\|case\\|method\\)\\'") (ruby-ts--align-keywords ruby-ts--parent-node) ruby-indent-level) ((and ruby-ts--align-chain-p (match "\\." "call")) ruby-ts--align-chain 0) ((and (not ruby-ts--method-call-indent-p) (or (match "\\." "call") (query "(call \".\" (identifier) @indent)"))) (ruby-ts--bol ruby-ts--statement-ancestor) ruby-indent-level) ((match "\\." "call") parent ruby-indent-level) ((and (query "(method_parameters \"(\" _ @indent)") ruby-ts--same-line-params-p (node-is ")")) first-sibling 0) ((and (query "(method_parameters \"(\" _ @indent)") ruby-ts--same-line-params-p) first-sibling 1) ((and (query "(method_parameters \"(\" _ @indent)") (node-is ")")) ruby-ts--param-indent 0) ((query "(method_parameters \"(\" _ @indent)") ruby-ts--param-indent ruby-indent-level) ((parent-is "method_parameters") first-sibling 0) ((and (query "(argument_list \"(\" _ @indent)") ruby-ts--same-line-args-p (node-is ")")) first-sibling 0) ((and (query "(argument_list \"(\" _ @indent)") ruby-ts--same-line-args-p) first-sibling 1) ((and (query "(argument_list \"(\" _ @indent)") (node-is ")")) ruby-ts--parent-call-or-bol 0) ((or (query "(argument_list \"(\" _ @indent)") (match "\\`\\'" "argument_list")) ruby-ts--parent-call-or-bol ruby-indent-level) ((and ruby-ts--parenless-call-arguments-indent-p (parent-is "argument_list")) first-sibling 0) ((parent-is "argument_list") (ruby-ts--bol ruby-ts--statement-ancestor) ruby-indent-level) ((parent-is "block_parameters") first-sibling 1) ((and (not ruby-ts--after-op-indent-p) (parent-is "binary\\|conditional")) (ruby-ts--bol ruby-ts--statement-ancestor) ruby-indent-level) ((parent-is "binary") ruby-ts--binary-indent-anchor 0) ((parent-is "conditional") parent ruby-indent-level) ((match "bare_string" "string_array") no-indent 0) ((and ruby-ts--same-line-hash-array-p (match "}" "hash")) first-sibling 0) ((and ruby-ts--same-line-hash-array-p (parent-is "hash")) (nth-sibling 0 ruby-ts--true) 0) ((and ruby-ts--same-line-hash-array-p (match "]" "array")) first-sibling 0) ((and ruby-ts--same-line-hash-array-p (parent-is "array")) (nth-sibling 0 ruby-ts--true) 0) ((match "}" "hash") ruby-ts--parent-call-or-bol 0) ((parent-is "hash") ruby-ts--parent-call-or-bol ruby-indent-level) ((match "]" "^array") ruby-ts--parent-call-or-bol 0) ((parent-is "^array") ruby-ts--parent-call-or-bol ruby-indent-level) ((match ")" "string_array") ruby-ts--parent-call-or-bol 0) ((parent-is "pair") ruby-ts--parent-call-or-bol 0) ((match ")" "parenthesized_statements") parent-bol 0) ((parent-is "parenthesized_statements") parent-bol ruby-indent-level) ((ruby-ts--bol ruby-ts--grand-parent-node) ruby-indent-level) (parent 0) (((node-is "body_statement") (ruby-ts--block-indent-anchor ruby-ts--parent-node) ruby-indent-level) ((parent-is "body_statement") (ruby-ts--block-indent-anchor ruby-ts--grand-parent-node) ruby-indent-level) ((match "end" "do_block") (ruby-ts--block-indent-anchor ruby-ts--parent-node) 0) ((n-p-gp "block_body" "block" nil) (ruby-ts--block-indent-anchor ruby-ts--parent-node) ruby-indent-level) ((n-p-gp nil "block_body" "block") (ruby-ts--block-indent-anchor ruby-ts--grand-parent-node) ruby-indent-level) ((match "}" "block") (ruby-ts--block-indent-anchor ruby-ts--parent-node) 0) ((match "string" "chained_string") first-sibling 0) (catch-all parent-bol ruby-indent-level)) ruby] 67 (#$ . 12355)])#@26 

(fn BLOCK-NODE-GETTER)
(defalias 'ruby-ts--block-indent-anchor #[257 "\300\301\"\207" [make-closure #[899 "\300\"\212\302	\203 \303!\202 !b\210\304 \210`)\207" [V0 ruby-block-indent treesit-node-start ruby-ts--statement-ancestor back-to-indentation] 8 "\n\n(fn NODE PARENT BOL &rest REST)"]] 4 (#$ . 18701)])#@32 

(fn NODE PARENT BOL &rest _)
(defalias 'ruby-ts--binary-indent-anchor #[899 "\212\302!b\210\303\304!!\305\306\307$\266\203\203 	u\210`)\207" [ruby-ts--statement-container-regexp ruby-indent-level treesit-node-start treesit-node-type treesit-node-parent nil string-match t] 12 (#$ . 19024)])#@31 

(fn NOT PARENT BOL &rest _)
(defalias 'ruby-ts--parent-call-or-bol #[899 "\212\302!b\210\303 \210`)\304\305\306\"\"\211\204 \207\302!W\203\" \207\307\310!\311\312\313$\266\203\203> \212\302\314\315\"!b\210`)\207\204O \212\302\316!!b\210`	\\)\207\310\314\317\"!\320\232\203f \212\302\314\315\"!b\210`)\207\212\302!b\210`)\207" [ruby-parenless-call-arguments-indent ruby-indent-level treesit-node-start back-to-indentation treesit-parent-until make-closure #[257 "\301!\300W\206 \302\303!\304\305\306$\266\203\206 \303!\307\232\207" [V0 treesit-node-start "\\`array\\|hash\\'" treesit-node-type nil string-match t "argument_list"] 9 "\n\n(fn NODE)"] "\\`array\\|hash\\'" treesit-node-type nil string-match t treesit-node-child 1 ruby-ts--statement-ancestor 0 "("] 14 (#$ . 19329)])#@16 

(fn &rest _)
(defalias 'ruby-ts--after-op-indent-p #[128 "\207" [ruby-after-operator-indent] 2 (#$ . 20142)])#@16 

(fn &rest _)
(defalias 'ruby-ts--method-call-indent-p #[128 "\207" [ruby-method-call-indent] 2 (#$ . 20260)])#@52 Predicate if NODE is a class or module.

(fn NODE)
(defalias 'ruby-ts--class-or-module-p #[257 "\301!\302\303\304$\207" [ruby-ts--class-or-module-regex treesit-node-type nil string-match t] 9 (#$ . 20378)])#@57 Return the text of the `name' field of NODE.

(fn NODE)
(defalias 'ruby-ts--get-name #[257 "\300\301\302\"!\207" [treesit-node-text treesit-node-child-by-field-name "name"] 5 (#$ . 20595)])#@53 Return the fully qualified name of NODE.

(fn NODE)
(defalias 'ruby-ts--full-name #[257 "\300!\301\302!\303\232\203 \304\262\305\306\307\"!\262\310\311\"\211\262\203; \2030 \300!Q\262\2025 \300!\262\312\262\202 \207" [ruby-ts--get-name "#" treesit-node-type "singleton_method" "." treesit-node-text treesit-node-child-by-field-name "name" treesit-parent-until ruby-ts--class-or-module-p "::"] 7 (#$ . 20791)])#@69 Convert a treesit sparse tree NODE in a flat imenu list.

(fn TREE)
(defalias 'ruby-ts--imenu-helper #[257 "\211A\203 \300\301A\"\207\302@!\303@!BC\207" [cl-mapcan ruby-ts--imenu-helper ruby-ts--full-name treesit-node-start] 4 (#$ . 21224)])#@44 Return Imenu alist for the current buffer.
(defalias 'ruby-ts--imenu #[0 "\300 \301\302\"\303!\207" [treesit-buffer-root-node treesit-induce-sparse-tree "^\\(?:alias\\|class\\|m\\(?:ethod\\|odule\\)\\|singleton_method\\)$" ruby-ts--imenu-helper] 4 (#$ . 21475)])#@51 Move to the start ARG levels up or out.

(fn ARG)
(defalias 'ruby-ts--arrow-up-start #[257 "\211\206 \300\262`\301!\302!\303\203; \203; \304V\203; \305!\262\302!\262\211\203 \211U\204 S\262\211\262\202 \203B b\207\306\307!\207" [1 treesit-node-at treesit-node-start nil 0 treesit-node-parent error "Something didn't work"] 7 (#$ . 21745) "p"])#@75 Return NODE's name.
Assumes NODE's type is "class" or "method"

(fn NODE)
(defalias 'ruby-ts--class-name #[257 "\300\301\302!\303\232\203 \304\202 \305\"\306\"C\207" [treesit-node-text treesit-node-child-by-field-name treesit-node-type "singleton_class" "value" "name" t] 6 (#$ . 22114)])#@95 Return the method name of NODE.
Assumes NODE's type is method or singleton_method.

(fn NODE)
(defalias 'ruby-ts--method-name #[257 "\300!\301\232\203 \302\303\304\"\305\"C\207\306!\211A@\3078\300!\310\232\2030 \302\3118\305\"\302\3128\305\"D\207\313\314D\"\207" [treesit-node-type "method" treesit-node-text treesit-node-child-by-field-name "name" t treesit-node-children 3 "(" 2 5 mapcar #[257 "\300\301\"\207" [treesit-node-text t] 4 "\n\n(fn N)"]] 8 (#$ . 22412)])#@269 Return the current method name as a string.
The hash (#) is for instance methods only which are methods
"defined on a class" -- which is 99% of methods.  Otherwise, a
dot (.) is used.  Double colon (::) is used between classes.  The
leading double colon is not added.
(defalias 'ruby-ts-add-log-current-function #[0 "\301`!\302\303\304#\211\206 \305\306\305\211\211\203( \307!\262G\310U\204( \311\262\303\312!\"\211\262\203A \313\314!\"\262\202( \315!@\262\316!\262@\315!@\232\203Z A\262\313\"\211\203\253 \211@\211\317\232\203p \311\262\202\244 \320\305\321\304$\266\203\203\224 \311\262\203\216 \322Q\202\217 \211\262\202\244 \203\241 \322Q\202\242 \211\262A\266\202\202^ \210\211\203\265 Q\207\207" [ruby-ts--class-or-module-regex treesit-node-at #[257 "\301!`X\205 \302!`Y\205 \303!\304\305\306$\266\203\207" [ruby-ts--method-regex treesit-node-start treesit-node-end treesit-node-type nil string-match t] 9 "\n\n(fn NODE)"] treesit-parent-until t nil "#" ruby-ts--method-name 1 "." ruby-ts--type-pred append ruby-ts--class-name last butlast "self" "\\`[^A-Z]" string-match "::"] 19 (#$ . 22898)])
(defvar ruby-ts--s-p-query (byte-code "\300 \205	 \301\302\303\"\207" [treesit-available-p treesit-query-compile ruby (((heredoc_body) @heredoc) ((global_variable) @global_var (:match "\\`\\$[#\"'`:?]" @global_var)) ((character) @char (:match "\\`\\?[#\"'`:?]" @char)) ((simple_symbol) @symbol (:match "\\s." @symbol)) ((call method: (identifier) @ident) (:match "[?!]\\'" @ident)) ((operator "`" @backtick)) ((regex "/" @regex_slash)) ((comment) @comm (:match "\\`=" @comm)) ((string) @percent (:match "\\`%" @percent)))] 3))#@16 

(fn BEG END)
(defalias 'ruby-ts--syntax-propertize #[514 "\301\302$\211\211\205\370 \211@\211\242\243\303\267\202\352 \304\305!\305!T\306\305!f\307=\203- \310\202. \311$\266\202\361 \304\312!S\312!\306\313$\266\202\361 \312!b\210\314\315\305!\"\210\304`\312!\306\313$\266\202\361 \304\305!\305!T\306\316$\210\312!dW\203\357 \304\312!\312!T\306\316$\266\202\361 \304\305!\305!T\306\311$\210\304\312!S\312!\306\311$\266\202\361 \304\305!\305!T\306\317$\210\304\305!T\312!\306\313$\266\202\361 \304\305!\312!\306\313$\266\202\361 \305!\312!SD\211\203\345 \211@\304\211T\306\320$\210A\266\202\202\320 \266\202\361 \321\322\"\210\266A\266\202\202 \207" [ruby-ts--s-p-query treesit-query-capture ruby #s(hash-table size 9 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (regex_slash 23 ident 52 symbol 68 heredoc 93 percent 129 char 157 global_var 157 backtick 185 comm 200)) put-text-property treesit-node-start syntax-table 47 (7 . 47) (15) treesit-node-end (3) skip-syntax-backward "." (7) (6) (14) error "No clause matching `%S'"] 14 (#$ . 24593)])#@26 Keymap used in Ruby mode
(defvar ruby-ts-mode-map (define-keymap :parent prog-mode-map "C-c {" 'ruby-toggle-block "C-c '" 'ruby-toggle-string-quotes "C-c C-f" 'ruby-find-library-file) (#$ . 25707))
(defvar ruby-ts-mode-hook nil)
(byte-code "\300\301N\204\f \302\300\301\303#\210\304\305!\204 \302\305\306\307#\210\300\207" [ruby-ts-mode-hook variable-documentation put "Hook run after entering Ruby mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp ruby-ts-mode-map definition-name ruby-ts-mode] 4)
(defvar ruby-ts-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204 \303\301\302\304\305!#\210\306\300!\204. \303\300\307\310#\210\311\300\306\300!\203& \312\202, \313\300\312\"\210\"\210\300\302N\204< \303\300\302\304\314!#\210\303\310\315\316#\210\303\310\317\320#\207" [ruby-ts-mode-abbrev-table ruby-ts-mode-map variable-documentation put purecopy "Keymap for `ruby-ts-mode'." boundp definition-name ruby-ts-mode defvar-1 nil define-abbrev-table "Abbrev table for `ruby-ts-mode'." derived-mode-parent ruby-base-mode custom-mode-group ruby] 5)#@251 Major mode for editing Ruby, powered by tree-sitter.

In addition to any hooks its parent mode `ruby-base-mode' might have
run, this mode runs the hook `ruby-ts-mode-hook', as the final or
penultimate step during initialization.

\{ruby-ts-mode-map}
(defalias 'ruby-ts-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203 \314\311\313\310\313N#\210\315!\204' \316\317 \"\210\320\f\321\"\204; \f=\204; \322\f\321C#\210\323!\210\324,!\210\f\325\326!\204P \327\330!\210\331\326!\210\306\332!\210\333\306\334!\210-\306\335!\210\336\306\337!\210\340\306\341!\210\342 !\306\343!\210\344\326!#\306\345!\210\346%\347 \210\306\350!\210\351()\352\353!\207" [delay-mode-hooks major-mode mode-name ruby-ts-mode-map ruby-ts-mode-abbrev-table local-abbrev-table make-local-variable t ruby-base-mode ruby-ts-mode "Ruby" mode-class put keymap-parent set-keymap-parent current-local-map abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table treesit-ready-p ruby error "Tree-sitter for Ruby isn't available" treesit-parser-create add-log-current-defun-function ruby-ts-add-log-current-function treesit-defun-type-regexp treesit-defun-prefer-top-level nil imenu-create-index-function ruby-ts--imenu treesit-simple-indent-rules ruby-ts--indent-rules treesit-font-lock-settings ruby-ts--font-lock-settings treesit-font-lock-feature-list ((comment method-definition parameter-definition) (keyword regexp string type) (builtin-variable builtin-constant builtin-function delimiter escape-sequence constant global instance interpolation literal symbol assignment) (bracket error function operator punctuation)) treesit-major-mode-setup syntax-propertize-function ruby-ts--syntax-propertize run-mode-hooks ruby-ts-mode-hook ruby-mode-syntax-table ruby-ts--method-regex] 5 (#$ . 26858) nil])
(byte-code "\300\301!\203 \302\303\304\305B\"\210\306\305!\207" [treesit-ready-p ruby add-to-list auto-mode-alist "\\(?:\\.\\(?:rbw?\\|ru\\|rake\\|thor\\|jbuilder\\|rabl\\|gemspec\\|podspec\\)\\|/\\(?:Gem\\|Rake\\|Cap\\|Thor\\|Puppet\\|Berks\\|Brew\\|Vagrant\\|Guard\\|Pod\\)file\\)\\'" ruby-ts-mode provide] 4)