emacsd/elpa/typescript-mode-20191120.346/typescript-mode.elc

;ELC
;;; Compiled
;;; in Emacs version 26.3
;;; 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!\210\300\302!\210\300\303!\210\300\304!\210\300\305!\207" [require compile cc-mode font-lock rx newcomment] 2)
#@73 Regexp matching the start of a typescript identifier, without grouping.
(defconst typescript--name-start-re "[a-zA-Z_$]" (#$ . 540))
#@60 Regexp matching a typescript identifier, without grouping.
(defconst typescript--name-re (concat typescript--name-start-re "\\(?:\\s_\\|\\sw\\)*") (#$ . 679))
#@57 Regexp matching the start of a typescript object field.
(defconst typescript--objfield-re (concat typescript--name-re ":") (#$ . 844))
#@63 Regexp matching a dot-separated sequence of typescript names.
(defconst typescript--dotted-name-re (concat typescript--name-re "\\(?:\\." typescript--name-re "\\)*") (#$ . 985))
#@180 Regexp matching an explicit typescript prototype "method" declaration.
Group 1 is a (possibly-dotted) class name, group 2 is a method name,
and group 3 is the 'function' keyword.
(defconst typescript--plain-method-re (concat "^\\s-*?\\(" typescript--dotted-name-re "\\)\\.prototype" "\\.\\(" typescript--name-re "\\)\\s-*?=\\s-*?\\(function\\)\\_>") (#$ . 1170))
#@129 Regexp matching a typescript explicit prototype "class" declaration.
An example of this is "Class.prototype = { method1: ...}".
(defconst typescript--plain-class-re (concat "^\\s-*\\(" typescript--dotted-name-re "\\)\\.prototype" "\\s-*=\\s-*{") (#$ . 1540))
#@69 Regexp matching ambient declaration modifier or export declaration.
(defconst typescript--module-declaration-re "^\\s-*\\(?:declare\\|\\(?:export\\(?:\\s-+default\\)?\\)\\)?" (#$ . 1805))
(defconst typescript--mp-class-decl-re (concat "^\\s-*var\\s-+" #1="\\(" typescript--name-re "\\)" "\\s-*=\\s-*" #1# typescript--dotted-name-re "\\)\\.extend\\(?:Final\\)?\\s-*(\\s-*{?\\s-*$"))
(defconst typescript--prototype-obsolete-class-decl-re (concat "^\\s-*\\(?:var\\s-+\\)?" "\\(" typescript--dotted-name-re "\\)" "\\s-*=\\s-*Class\\.create()"))
(defconst typescript--prototype-objextend-class-decl-re-1 (concat "^\\s-*Object\\.extend\\s-*(" "\\(" typescript--dotted-name-re "\\)" "\\s-*,\\s-*{"))
(defconst typescript--prototype-objextend-class-decl-re-2 (concat "^\\s-*\\(?:var\\s-+\\)?" "\\(" typescript--dotted-name-re "\\)" "\\s-*=\\s-*Object\\.extend\\s-*("))
(defconst typescript--prototype-class-decl-re (concat "^\\s-*\\(?:var\\s-+\\)?" "\\(" typescript--name-re "\\)" "\\s-*=\\s-*Class\\.create\\s-*(\\s-*" "\\(?:\\(" typescript--dotted-name-re "\\)\\s-*,\\s-*\\)?{?"))
(defconst typescript--dojo-class-decl-re (concat "^\\s-*dojo\\.declare\\s-*(\"\\(" typescript--dotted-name-re "\\)"))
#@63 Regexp matching an ExtTYPESCRIPT class declaration (style 1).
(defconst typescript--exttypescript-class-decl-re-1 (concat "^\\s-*Ext\\.extend\\s-*(" "\\s-*\\(" typescript--dotted-name-re #1="\\)" "\\s-*,\\s-*\\(" typescript--dotted-name-re #1#) (#$ . 3005))
#@63 Regexp matching an ExtTYPESCRIPT class declaration (style 2).
(defconst typescript--exttypescript-class-decl-re-2 (concat "^\\s-*\\(?:var\\s-+\\)?" #1="\\(" typescript--name-re #2="\\)" "\\s-*=\\s-*Ext\\.extend\\s-*(\\s-*" #1# typescript--dotted-name-re #2#) (#$ . 3269))
#@47 Regexp matching a MochiKit class declaration.
(defconst typescript--mochikit-class-re (concat "^\\s-*MochiKit\\.Base\\.update\\s-*(\\s-*" "\\(" typescript--dotted-name-re "\\)") (#$ . 3547))
(defconst typescript--dummy-class-style '(:name "[Automatically Generated Class]"))
#@773 List of typescript class definition styles.

A class definition style is a plist with the following keys:

:name is a human-readable name of the class type

:class-decl is a regular expression giving the start of the
class.  Its first group must match the name of its class.  If there
is a parent class, the second group should match, and it should be
the name of the class.

If :prototype is present and non-nil, the parser will merge
declarations for this constructs with others at the same lexical
level that have the same name.  Otherwise, multiple definitions
will create multiple top-level entries.  Don't use :prototype
unnecessarily: it has an associated cost in performance.

If :strip-prototype is present and non-nil, then if the class
name as matched contains
(defconst typescript--class-styles (byte-code "\306\307\310\311BBBB\306\312\310	\313BBBB\306\314\310\n\315BBBB\306\316\310\317BBBB\306\320\310\f\321BBBB\306\322\310
\323BBBB\306\324\310\325BBBB\306\326\310\327BBBB\306\330\310\331BBBB\306\332\310\333BBBB\257\n\207" [typescript--plain-class-re typescript--mochikit-class-re typescript--prototype-obsolete-class-decl-re typescript--prototype-class-decl-re typescript--prototype-objextend-class-decl-re-1 typescript--prototype-objextend-class-decl-re-2 :name "Plain" :class-decl (:prototype t :contexts (toplevel) :framework typescript) "MochiKit" (:prototype t :contexts (toplevel) :framework mochikit) "Prototype (Obsolete)" (:contexts (toplevel) :framework prototype) "Prototype (Modern)" (:contexts (toplevel) :framework prototype) "Prototype (Object.extend)" (:prototype t :contexts (toplevel) :framework prototype) "Prototype (Object.extend) 2" (:prototype t :contexts (toplevel) :framework prototype) "Dojo" (:contexts (toplevel) :framework dojo) "ExtTYPESCRIPT (style 1)" (:prototype t :contexts (toplevel) :framework exttypescript) "ExtTYPESCRIPT (style 2)" (:contexts (toplevel) :framework exttypescript) "Merrill Press" (:contexts (toplevel) :framework merrillpress) typescript--dojo-class-decl-re typescript--exttypescript-class-decl-re-1 typescript--exttypescript-class-decl-re-2 typescript--mp-class-decl-re] 14) (#$ . 3829))
#@50 List of available typescript frameworks symbols.
(defconst typescript--available-frameworks (byte-code "\305	\305\211\305\n:\203)\n@\306\307\"\211>\204\"\fC\244\nA\211\202-\207" [available-frameworks typescript--class-styles #1=#:--cl-var-- style framework nil plist-get :framework] 4) (#$ . 6004))
#@103 Regexp matching the start of a typescript function header.
Match group 1 is the name of the function.
(defconst typescript--function-heading-1-re (concat typescript--module-declaration-re "\\s-*function\\s-+\\(" typescript--name-re "\\)") (#$ . 6327))
#@115 Regexp matching the start of a function entry in an associative array.
Match group 1 is the name of the function.
(defconst typescript--function-heading-2-re (concat "^\\s-*\\(" typescript--name-re "\\)\\s-*:\\s-*function\\_>") (#$ . 6586))
#@97 Regexp matching a line in the typescript form "var MUMBLE = function".
Match group 1 is MUMBLE.
(defconst typescript--function-heading-3-re (concat "^\\s-*\\(?:var\\s-+\\)?\\(" typescript--dotted-name-re "\\)" "\\s-*=\\s-*function\\_>") (#$ . 6833))
#@68 Like `regexp-opt', but surround the result with `\\_<' and `\\_>'.
(defalias 'typescript--regexp-opt-symbol #[(list) "\301\302\303\"\304Q\207" [list "\\_<" regexp-opt t "\\_>"] 4 (#$ . 7089)])
#@41 Regexp matching any typescript keyword.
(defconst typescript--keyword-re (typescript--regexp-opt-symbol '("abstract" "any" "as" "async" "await" "boolean" "bigint" "break" "case" "catch" "class" "const" "constructor" "continue" "declare" "default" "delete" "do" "else" "enum" "export" "extends" "extern" "false" "finally" "for" "function" "from" "get" "goto" "if" "implements" "import" "in" "instanceof" "interface" "keyof" "let" "module" "namespace" "never" "new" "null" "number" "object" "of" "private" "protected" "public" "readonly" "return" "set" "static" "string" "super" "switch" "this" "throw" "true" "try" "type" "typeof" "unknown" "var" "void" "while")) (#$ . 7289))
#@64 Regular expression matching any predefined type in typescript.
(defconst typescript--basic-type-re (typescript--regexp-opt-symbol '("any" "bool" "boolean" "bigint" "never" "number" "string" "unknown" "void")) (#$ . 7971))
#@47 Regular expression matching access modifiers.
(defconst typescript--access-modifier-re (typescript--regexp-opt-symbol '("private" "protected" "public" "readonly" "static" "extends" "implements")) (#$ . 8199))
(defconst typescript--decorator-re (concat "\\(@" typescript--name-re "\\)"))
#@70 Regular expression matching any future reserved words in typescript.
(defconst typescript--constant-re (typescript--regexp-opt-symbol '("false" "null" "undefined" "Infinity" "NaN" "true" "arguments" "this")) (#$ . 8492))
#@39 Regular expression matching builtins.
(defconst typescript--builtin-re (typescript--regexp-opt-symbol '("console")) (#$ . 8719))
#@45 Regular expression matching function calls.
(defconst typescript--function-call-re "\\(\\w+\\)\\(<.+>\\)? *(" (#$ . 8854))
#@53 Level one font lock keywords for `typescript-mode'.
(defconst typescript--font-lock-keywords-1 (byte-code "\303\304	E\n\304	EE\207" [typescript--function-heading-1-re font-lock-function-name-face typescript--function-heading-2-re "\\_<import\\_>" 1] 5) (#$ . 8983))
#@53 Level two font lock keywords for `typescript-mode'.
(defconst typescript--font-lock-keywords-2 (byte-code "\306	\307\nE\310\311\312\211\307\302D\257\313\302B\fB
\fB\257\"\207" [typescript--font-lock-keywords-1 typescript--keyword-re font-lock-keyword-face typescript--basic-type-re font-lock-type-face typescript--constant-re append 1 "\\_<for\\_>" "\\s-+\\(each\\)\\_>" nil "\\_<yield\\(\\*\\|\\_>\\)" font-lock-constant-face] 9) (#$ . 9256))
#@59 compiler-macro for inlining `typescript--pitem-children'.
(defalias 'typescript--pitem-children--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block typescript--pitem-children (car cl-x)) nil] 7 (#$ . 9711)])
(put 'typescript--pitem-children 'compiler-macro 'typescript--pitem-children--cmacro)
#@75 Access slot "children" of `(typescript--pitem (:type list))' struct CL-X.
(defalias 'typescript--pitem-children #[(cl-x) "@\207" [cl-x] 1 (#$ . 10067)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put typescript--pitem-children side-effect-free t gv-expander #[(_cl-do _cl-x) "\300\301\302\"\207" [error "%s is a read-only slot" typescript--pitem-children] 3]] 5)
#@62 compiler-macro for inlining `typescript--pitem-paren-depth'.
(defalias 'typescript--pitem-paren-depth--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block typescript--pitem-paren-depth (nth 1 cl-x)) nil] 7 (#$ . 10460)])
(put 'typescript--pitem-paren-depth 'compiler-macro 'typescript--pitem-paren-depth--cmacro)
#@78 Access slot "paren-depth" of `(typescript--pitem (:type list))' struct CL-X.
(defalias 'typescript--pitem-paren-depth #[(cl-x) "A@\207" [cl-x] 1 (#$ . 10834)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put typescript--pitem-paren-depth side-effect-free t gv-expander #[(_cl-do _cl-x) "\300\301\302\"\207" [error "%s is a read-only slot" typescript--pitem-paren-depth] 3]] 5)
#@55 compiler-macro for inlining `typescript--pitem-type'.
(defalias 'typescript--pitem-type--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block typescript--pitem-type (nth 2 cl-x)) nil] 7 (#$ . 11240)])
(put 'typescript--pitem-type 'compiler-macro 'typescript--pitem-type--cmacro)
#@71 Access slot "type" of `(typescript--pitem (:type list))' struct CL-X.
(defalias 'typescript--pitem-type #[(cl-x) "\3018\207" [cl-x 2] 2 (#$ . 11579)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put typescript--pitem-type side-effect-free t gv-expander #[(_cl-do _cl-x) "\300\301\302\"\207" [error "%s is a read-only slot" typescript--pitem-type] 3]] 5)
#@58 compiler-macro for inlining `typescript--pitem-h-begin'.
(defalias 'typescript--pitem-h-begin--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block typescript--pitem-h-begin (nth 3 cl-x)) nil] 7 (#$ . 11962)])
(put 'typescript--pitem-h-begin 'compiler-macro 'typescript--pitem-h-begin--cmacro)
#@74 Access slot "h-begin" of `(typescript--pitem (:type list))' struct CL-X.
(defalias 'typescript--pitem-h-begin #[(cl-x) "\3018\207" [cl-x 3] 2 (#$ . 12316)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put typescript--pitem-h-begin side-effect-free t gv-expander #[(_cl-do _cl-x) "\300\301\302\"\207" [error "%s is a read-only slot" typescript--pitem-h-begin] 3]] 5)
#@55 compiler-macro for inlining `typescript--pitem-name'.
(defalias 'typescript--pitem-name--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block typescript--pitem-name (nth 4 cl-x)) nil] 7 (#$ . 12711)])
(put 'typescript--pitem-name 'compiler-macro 'typescript--pitem-name--cmacro)
#@71 Access slot "name" of `(typescript--pitem (:type list))' struct CL-X.
(defalias 'typescript--pitem-name #[(cl-x) "\3018\207" [cl-x 4] 2 (#$ . 13050)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put typescript--pitem-name side-effect-free t gv-expander #[(_cl-do _cl-x) "\300\301\302\"\207" [error "%s is a read-only slot" typescript--pitem-name] 3]] 5)
#@56 compiler-macro for inlining `typescript--pitem-b-end'.
(defalias 'typescript--pitem-b-end--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block typescript--pitem-b-end (nth 5 cl-x)) nil] 7 (#$ . 13433)])
(put 'typescript--pitem-b-end 'compiler-macro 'typescript--pitem-b-end--cmacro)
#@72 Access slot "b-end" of `(typescript--pitem (:type list))' struct CL-X.
(defalias 'typescript--pitem-b-end #[(cl-x) "\3018\207" [cl-x 5] 2 (#$ . 13777)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put typescript--pitem-b-end side-effect-free t defalias copy-typescript--pitem copy-sequence] 4)
#@130 compiler-macro for inlining `make-typescript--pitem'.

(fn CL-WHOLE &cl-quote &key CHILDREN PAREN-DEPTH TYPE H-BEGIN NAME B-END)
(defalias 'make-typescript--pitem--cmacro #[(cl-whole &rest #1=#:--cl-rest--) "\306\307\"A@\306\310\"A@\306\311\"A@\306\312\"A@\306\313\"A@\306\314\"A@\203^@\315>\203EAA\211\2020\316>A@\203T\317\211\2020\320\321@\"\210\202.)\322\323\324\317\317	\n\f
&.\207" [#1# children paren-depth type h-begin name plist-member :children :paren-depth :type :h-begin :name :b-end (:children :paren-depth :type :h-begin :name :b-end :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:children :paren-depth :type :h-begin :name :b-end)" cl--defsubst-expand (children paren-depth type h-begin name b-end) (cl-block make-typescript--pitem (list children paren-depth type h-begin name b-end)) b-end #2=#:--cl-keys-- cl-whole] 13 (#$ . 14094)])
(put 'make-typescript--pitem 'compiler-macro 'make-typescript--pitem--cmacro)
#@110 Constructor for objects of type `typescript--pitem'.

(fn &key CHILDREN PAREN-DEPTH TYPE H-BEGIN NAME B-END)
(defalias 'make-typescript--pitem #[(&rest #1=#:--cl-rest--) "\306\307\"A@\306\310\"A@\306\311\"A@\306\312\"A@\306\313\"A@\306\314\"A@\203^@\315>\203EAA\211\2020\316>A@\203T\317\211\2020\320\321@\"\210\202.)	\n\f
\257.\207" [#1# children paren-depth type h-begin name plist-member :children :paren-depth :type :h-begin :name :b-end (:children :paren-depth :type :h-begin :name :b-end :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:children :paren-depth :type :h-begin :name :b-end)" b-end #2=#:--cl-keys--] 7 (#$ . 15105)])
(byte-code "\300\301\302\303#\304\305\306\211\307\306\310\311\305\306&	\207" [function-put make-typescript--pitem side-effect-free t cl-struct-define typescript--pitem nil list ((children nil :read-only t) (paren-depth nil :read-only t) (type nil :read-only t) (h-begin nil :read-only t) (name nil :read-only t) (b-end nil)) cl-struct-typescript--pitem-tags] 11)
(defconst typescript--initial-pitem (byte-code "\301\302\301\211\211\257\207" [most-negative-fixnum nil toplevel] 6))
#@25 Matches a typedoc link.
(defconst typescript-typedoc-link-tag-regexp "\\[\\[.*?\\]\\]" (#$ . 16301))
#@35 Matches a typedoc keyword markup.
(defconst typescript-typedoc-literal-markup-regexp "\\(`+\\).*?\\1" (#$ . 16408))
#@58 Matches everything we allow before the @ of a jsdoc tag.
(defconst typescript-jsdoc-before-tag-regexp "\\(?:^\\s-*\\*+\\|/\\*\\*\\)\\s-*" (#$ . 16530))
#@64 Matches jsdoc tags with optional type and optional param name.
(defconst typescript-jsdoc-param-tag-regexp (concat typescript-jsdoc-before-tag-regexp "\\(@" "\\(?:arg\\(?:ument\\)?\\|p\\(?:aram\\|rop\\(?:erty\\)?\\)\\|typedef\\)" "\\)" "\\s-*\\({[^}]+}\\)?" "\\s-*\\[?\\([[:alnum:]_$.]+\\)?\\]?" "\\_>") (#$ . 16688))
#@40 Matches jsdoc tags with optional type.
(defconst typescript-jsdoc-typed-tag-regexp (concat typescript-jsdoc-before-tag-regexp "\\(@" "\\(?:e\\(?:num\\|xtends\\)\\|field\\|i\\(?:d\\|mplements\\)\\|lends\\|mods\\|re\\(?:quires\\|turns?\\)\\|t\\(?:hrows?\\|ype\\)\\|yields?\\)" "\\)\\s-*\\({[^}]+}\\)?") (#$ . 17012))
#@44 Matches jsdoc tags with a single argument.
(defconst typescript-jsdoc-arg-tag-regexp (concat typescript-jsdoc-before-tag-regexp "\\(@" "\\(?:a\\(?:\\(?:cces\\|lia\\|ugment\\)s\\)\\|b\\(?:ase\\|orrows\\|ug\\)\\|c\\(?:allback\\|onfig\\)\\|def\\(?:ault\\|ine\\)\\|e\\(?:mits\\|x\\(?:ception\\|te\\(?:nds\\|rnal\\)\\)\\)\\|f\\(?:ires\\|unc\\(?:tion\\)?\\)\\|host\\|kind\\|listens\\|m\\(?:e\\(?:mber\\(?:of\\)?\\|thod\\)\\|ixes\\|odule\\)\\|name\\(?:space\\)?\\|requires\\|s\\(?:ince\\|uppress\\)\\|th\\(?:\\(?:i\\|row\\)s\\)\\|v\\(?:ar\\(?:iation\\)?\\|ersion\\)\\)" "\\)\\s-+\\([^ 	]+\\)") (#$ . 17333))
#@27 Matches empty jsdoc tags.
(defconst typescript-jsdoc-empty-tag-regexp (concat typescript-jsdoc-before-tag-regexp "\\(@" "\\(?:a\\(?:bstract\\|ddon\\|sync\\|uthor\\)\\|c\\(?:lass\\(?:desc\\)?\\|o\\(?:nst\\(?:ant\\|ruct\\(?:or\\|s\\)\\)?\\|pyright\\)\\)\\|de\\(?:fault\\(?:value\\)?\\|precated\\|sc\\(?:ription\\)?\\)\\|e\\(?:vent\\|x\\(?:ample\\|ec\\|ports?\\)\\)\\|f\\(?:i\\(?:le\\(?:overview\\)?\\|nal\\)\\|unc\\(?:tion\\)?\\)\\|g\\(?:enerator\\|lobal\\)\\|hid\\(?:den\\|econstructor\\)\\|i\\(?:gnore\\|mplicitcast\\|n\\(?:heritdoc\\|ner\\|\\(?:stan\\|terfa\\)ce\\)\\)\\|license\\|m\\(?:ethod\\|ixin\\)\\|no\\(?:alias\\|shadow\\|typecheck\\)\\|o\\(?:ver\\(?:ride\\|view\\)\\|wner\\)\\|p\\(?:ackage\\|r\\(?:eserve\\(?:try\\)?\\|ivate\\|otected\\)\\|ublic\\)\\|readonly\\|s\\(?:tatic\\|u\\(?:mmary\\|pported\\)\\)\\|t\\(?:odo\\|utorial\\)\\|virtual\\)" "\\)\\s-*") (#$ . 17940))
#@23 Matches tslint flags.
(defconst typescript-tslint-flag-regexp "\\(?://\\|/\\*\\)\\s-*\\(tslint:.*?\\)\\(?:\\*/\\|$\\)" (#$ . 18824))
(byte-code "\301\302\303\304\305\306%\210\301\307\310\311\305\306%\210\301\312\313\314\305\306%\210\301\315\316\317\305\306%\210\301\320\321\322\305\306%\210\301\323\324\325\305\306%\210\326\306\327\330\331\332\305\333&\210\334\335\336\337\340\341\342\343\305\306&	\210\334\344\345\346\340\341\342\343\305\306&	\210\334\347\350\351\340\352\305\306&\210\334\353\350\354\340\352\305\306&\210\334\355\327\356\340\352\305\306&\210\334\357\360\361\340\362\305\306&\210\334\363\300\364\340\365\366\367\"B\305\306&\210\334\370\327\371\340\372\305\306&\210\334\373\327\374\340\352\305\306&\207" [typescript--available-frameworks custom-declare-face typescript-jsdoc-tag ((t :foreground "SlateGray")) "Face used to highlight @whatever tags in jsdoc comments." :group typescript typescript-jsdoc-type ((t :foreground "SteelBlue")) "Face used to highlight {FooBar} types in jsdoc comments." typescript-jsdoc-value ((t :foreground "gold4")) "Face used to highlight tag values in jsdoc comments." typescript-access-modifier-face ((t (:inherit font-lock-keyword-face))) "Face used to highlight access modifiers." typescript-this-face ((t (:inherit font-lock-keyword-face))) "Face used to highlight 'this' keyword." typescript-primitive-face ((t (:inherit font-lock-keyword-face))) "Face used to highlight builtin types." custom-declare-group nil "Customization variables for typescript mode." :tag "typescript" languages custom-declare-variable typescript-indent-level 4 "Number of spaces for each indentation step in `typescript-mode'." :type integer :safe integerp typescript-expr-indent-offset 0 "Number of additional spaces used for indentation of continued expressions.\nThe value must be no less than minus `typescript-indent-level'." typescript-indent-switch-clauses t "Enable indenting of switch case and default clauses to\nreplicate tsserver behaviour. Indent level is taken to be\n`typescript-indent-level'." boolean typescript-auto-indent-flag "Whether to automatically indent when typing punctuation characters.\nIf non-nil, the characters {}();,: also indent the current line\nin typescript mode." typescript-flat-functions "Treat nested functions as top-level functions in `typescript-mode'.\nThis applies to function movement, marking, and so on." typescript-comment-lineup-func #'c-lineup-C-comments "Lineup function for `cc-mode-style', for C comments in `typescript-mode'." function typescript-enabled-frameworks "Frameworks recognized by `typescript-mode'.\nTo improve performance, you may turn off some frameworks you\nseldom use, either globally or on a per-buffer basis." set mapcar #[(x) "\301D\207" [x const] 2] typescript-mode-hook "*Hook called by `typescript-mode'." hook typescript-autoconvert-to-template-flag "Non-nil means automatically convert plain strings to templates.\n\nWhen the flag is non-nil the `typescript-autoconvert-to-template'\nis called whenever a plain string delimiter is typed in the buffer."] 10)
#@51 Convert the string at point to a template string.
(defalias 'typescript-convert-to-template #[nil "\214~\210\212\304 \3058\211\203\3068\206\307u\210`\310 \205B\306\304 8\206'\311\312 \210\nU\2038\313\314!\210\315c\210)\nb\210\313\314!\210\315c-\207" [syntax str-terminator string-start end-start syntax-ppss 3 8 nil typescript--move-to-end-of-plain-string -1 undo-boundary delete-char 1 "`"] 3 (#$ . 21908) nil])
#@376 Automatically convert a plain string to a teplate string, if needed.

This function is meant to be automatically invoked when the user
enters plain string delimiters.  It checks whether the character
before point is the end of a string.  If it is, then it checks
whether the string contains ${...}.  If it does, then it converts
the string from a plain string to a template.
(defalias 'typescript-autoconvert-to-template #[nil "\214~\210\212\301u\210\302f\303>\205-`Sf\304=?\205-\305\306 8\211\205,\212\307\310\311#)\205,\312 )*\207" [string-start -1 nil (39 34) 92 8 syntax-ppss re-search-backward "\\${.*?}" t typescript-convert-to-template] 5 (#$ . 22342) nil])
#@31 Keymap for `typescript-mode'.
(defvar typescript-mode-map (byte-code "\303 \304\305\211\203\n@\306	\307#\210\nA\211\204*\310\305\211\2034\n@\306	\311#\210\nA\211\204$*\306\312\313#\210)\207" [keymap key --dolist-tail-- make-sparse-keymap ("{" "}" "(" ")" ":" ";" ",") nil define-key typescript-insert-and-indent ("\"" "'") typescript-insert-and-autoconvert-to-template "'" typescript-convert-to-template] 5) (#$ . 23019))
#@124 Run the command bound to KEY, and indent if necessary.
Indentation does not take place if point is in a string or
comment.
(defalias 'typescript-insert-and-indent #[(key) "\303\304\305 \"!\210\214~\210\306 )\307	8\204\n\204'\310	8\205)i\311 T=\205)\312 )\207" [key syntax typescript-auto-indent-flag call-interactively lookup-key current-global-map syntax-ppss 8 4 current-indentation indent-according-to-mode] 4 (#$ . 23468) (list (this-command-keys))])
(put 'typescript-insert-and-indent 'delete-selection t)
#@73 Run the command bount to KEY, and autoconvert to template if necessary.
(defalias 'typescript-insert-and-autoconvert-to-template #[(key) "\302\303\304 \"!\210	\205\305 \207" [key typescript-autoconvert-to-template-flag call-interactively lookup-key current-global-map typescript-autoconvert-to-template] 4 (#$ . 23992) (list (this-command-keys))])
(put 'typescript-insert-and-autoconvert-to-template 'delete-selection t)
#@37 Syntax table for `typescript-mode'.
(defvar typescript-mode-syntax-table (byte-code "\301 \302!\210\303\304\305#\210\303\306\307#\210)\207" [table make-syntax-table c-populate-syntax-table modify-syntax-entry 36 "_" 96 "\""] 4) (#$ . 24422))
#@76 Autogenerated regexp used by `typescript-mode' to match buffer constructs.
(defvar typescript--quick-match-re nil (#$ . 24675))
#@83 Autogenerated regexp used by `typescript-mode' to match constructs and functions.
(defvar typescript--quick-match-re-func nil (#$ . 24809))
(byte-code "\300\301!\210\300\302!\207" [make-variable-buffer-local typescript--quick-match-re typescript--quick-match-re-func] 2)
#@70 Last valid buffer position for the `typescript-mode' function cache.
(defvar typescript--cache-end 1 (#$ . 25086))
(make-variable-buffer-local 'typescript--cache-end)
#@62 Latest parse position reached by `typescript--ensure-cache'.
(defvar typescript--last-parse-pos nil (#$ . 25259))
(make-variable-buffer-local 'typescript--last-parse-pos)
#@46 Parse state at `typescript--last-parse-pos'.
(defvar typescript--state-at-last-parse-pos nil (#$ . 25436))
(make-variable-buffer-local 'typescript--state-at-last-parse-pos)
(defalias 'typescript--flatten-list #[(list) "\304\211	:\203*	@\211:\203\305\n!\202\n\205\nC\237\244	A\211\202\237+\207" [list #1=#:--cl-var-- item #2=#:--cl-var-- nil typescript--flatten-list] 3])
#@323 Helper function for `typescript--update-quick-match-re'.
If LIST contains any element that is not nil, return its non-nil
elements, separated by SEPARATOR, prefixed by PREFIX, and ended
with SUFFIX as with `concat'.  Otherwise, if LIST is empty, return
nil.  If any element in LIST is itself a list, flatten that
element.
(defalias 'typescript--maybe-join #[(prefix separator suffix &rest list) "\304!\211\205	\305\306\n#Q\207" [list prefix separator suffix typescript--flatten-list mapconcat identity] 6 (#$ . 25832)])
#@167 Internal function used by `typescript-mode' for caching buffer constructs.
This updates `typescript--quick-match-re', based on the current set of
enabled frameworks.
(defalias 'typescript--update-quick-match-re #[nil "\303\304\305\306\307\310>\205\f\311\312>\205\313\303\314\305\315\312>\205\316\310>\205%\311\317>\205,\320&\321>\2055\322\323>\205<\324\303\325\305\306\326>\205G\327$&\n\330	P\211\207" [typescript-enabled-frameworks typescript--quick-match-re typescript--quick-match-re-func typescript--maybe-join "^[ 	]*\\(?:" "\\|" "\\)" "#define[ 	]+[a-zA-Z_]" exttypescript "Ext\\.extend" prototype "Object\\.extend" "\\(?:var[ 	]+\\)?[a-zA-Z_$0-9.]+[ 	]*=[ 	]*\\(?:" "\\)[ 	]*(" "Class\\.create" merrillpress "[a-zA-Z_$0-9]+\\.extend\\(?:Final\\)?" dojo "dojo\\.declare[ 	]*(" mochikit "MochiKit\\.Base\\.update[ 	]*(" "[a-zA-Z_$0-9.]+\\.prototype\\(?:" typescript ("\\.[a-zA-Z_$0-9]+[ 	]*=[ 	]*function[ 	]*(" "[ 	]*=[ 	]*{") "function\\|"] 16 (#$ . 26365)])
#@182 Move over the next value of PROPNAME in the buffer.
If found, return that value and leave point after the character
having that value; otherwise, return nil and leave point at EOB.
(defalias 'typescript--forward-text-property #[(propname) "\302`\"\211\203\303u\210\202#\304`\303d$b\210m\204#\302`\"\303u\210	)\207" [propname next-value get-text-property nil next-single-property-change] 6 (#$ . 27359)])
#@193 Move over the previous value of PROPNAME in the buffer.
If found, return that value and leave point just before the
character that has that value, otherwise return nil and leave
point at BOB.
(defalias 'typescript--backward-text-property #[(propname) "o?\205+\302`S\"\211\203\303u\210\202)\304`\305e$b\210o\204)\303u\210\302`\"	)\207" [propname prev-value get-text-property -1 previous-single-property-change nil] 6 (#$ . 27779)])
(defalias 'typescript--forward-pstate #[nil "\300\301!\207" [typescript--forward-text-property typescript--pstate] 2])
(put 'typescript--forward-pstate 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'typescript--backward-pstate #[nil "\300\301!\207" [typescript--backward-text-property typescript--pstate] 2])
(put 'typescript--backward-pstate 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'typescript--pitem-goto-h-end #[(pitem) "\3018b\210\302\303!\207" [pitem 3 typescript--forward-text-property typescript--pstate] 2])
#@54 Helper function for `typescript--re-search-forward'.
(defalias 'typescript--re-search-forward-inner #[(regexp &optional bound count) "\305\211\n\306V\203c\307\f\"\210\310 \311	8\211\2034\312=\203\"\313\307\314\315!P\212\305\210`)\312#\210\202\316	8\203@\305y\210\202\317	8\204U`Sf\313=\203\\\305f\320=\203\\\307\321!\210\202\nS\211\202*`\207" [str-terminator parse count regexp bound nil 0 re-search-forward syntax-ppss 3 t 47 "\\([^\\]\\|^\\)" string 7 4 42 "\\*/"] 5 (#$ . 28767)])
#@159 Search forward, ignoring strings and comments.
This function invokes `re-search-forward', but treats the buffer
as if strings and comments have been removed.
(defalias 'typescript--re-search-forward #[(regexp &optional bound noerror count) "`\204	\305\202\306W\203\307\202\306V\205\310\3111'\312	!0\2026\nb\210\f?\2055\313\314!!)*\207" [count search-expr saved-point err noerror (typescript--re-search-forward-inner regexp bound 1) 0 (typescript--re-search-backward-inner regexp bound (- count)) (typescript--re-search-forward-inner regexp bound count) (search-failed) eval error error-message-string] 3 (#$ . 29283)])
#@58 Auxiliary function for `typescript--re-search-backward'.
(defalias 'typescript--re-search-backward-inner #[(regexp &optional bound count) "\304	\305V\203O\306\n\"\210`eV\203!\212\307u\210\310\311!)\203!\304u\210\312 \3138\2032\3138b\210\202`Sf\314=\203H\304f\315=\203H\306\316!\210\202	S\211\202)`\207" [parse count regexp bound nil 0 re-search-backward -1 looking-at "/[/*]" syntax-ppss 8 47 42 "/\\*"] 4 (#$ . 29927)])
#@612 Search backward, ignoring strings, and comments.

This function invokes `re-search-backward' but treats the buffer
as if strings and comments have been removed.

IMPORTANT NOTE: searching for "\n" with this function to find
line breaks will generally not work, because the final newline of
a one-line comment is considered to be part of the comment and
will be skipped.  Take the following code:

  let a = 1;
  let b = 2; // Foo
  let c = 3;

If the point is in the last line, searching back for "\n" will
skip over the line with "let b". The newline found will be the
one at the end of the line with "let a".
(defalias 'typescript--re-search-backward #[(regexp &optional bound noerror count) "`\204	\305\202\306W\203\307\202\306V\205\310\3111'\312	!0\2026\nb\210\f?\2055\313\314!!)*\207" [count search-expr saved-point err noerror (typescript--re-search-backward-inner regexp bound 1) 0 (typescript--re-search-forward-inner regexp bound (- count)) (typescript--re-search-backward-inner regexp bound count) (search-failed) eval error error-message-string] 3 (#$ . 30373)])
#@118 Move forward over a whole typescript expression.
This function doesn't move over expressions continued across
lines.
(defalias 'typescript--forward-expression #[nil "\301!\210l\204\301!\210\302f\303>\204\304 \210\202\302f\305=\203*\212\302u\210\306 )\204\302\207" [most-positive-fixnum forward-comment nil (44 59 93 41 125) forward-sexp 10 typescript--continued-expression-p] 2 (#$ . 31473)])
#@257 Move forward over a typescript function declaration.
This puts point at the 'function' keyword.

If this is a syntactically-correct non-expression function,
return the name of the function, or t if the name could not be
determined.  Otherwise, return nil.
(defalias 'typescript--forward-function-decl #[nil "\303\304!\204\n\305\306!\210\307\310v\210\311	!\210\303\n!\203!\312\313!\313\225b\210\311	!\210\310f\314=\205L\31518\316 \210\3070\202=\210\310\202L\205L\311	!\210\310f\317=\205L)\207" [name most-positive-fixnum typescript--name-re looking-at #1="\\_<function\\_>" cl--assertion-failed (looking-at #1#) t nil forward-comment match-string-no-properties 0 40 (error) forward-list 123] 2 (#$ . 31884)])
#@246 Return the start of the typescript function prologue containing POS.
A function prologue is everything from start of the definition up
to and including the opening brace.  POS defaults to point.
If POS is not in a function prologue, return nil.
(defalias 'typescript--function-prologue-beginning #[(&optional pos) "\305\212	\203
	b\210\202`\212\306y\210\307\n!\206\307!)\203-\310\224\211	X\203-\306\225b\210\311\312!\210\307\313!\204?\314\313\305\315#\205Z\316 \317\216\306\224b\210\320 *\205Z	`X\205Z\206Z\306\224*\207" [prologue-begin pos typescript--function-heading-2-re typescript--function-heading-3-re save-match-data-internal nil 0 looking-at 1 skip-syntax-backward "w_" "\\_<function\\_>" typescript--re-search-backward t match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] typescript--forward-function-decl] 5 (#$ . 32610)])
#@187 Helper function for `typescript-beginning-of-defun'.
Go to previous defun-beginning and return the parse state for it,
or nil if we went all the way back to bob and don't find
anything.
(defalias 'typescript--beginning-of-defun-raw #[nil "\301 \210\302\303\304!\211\203\305@8\306=\203o?\205)\207" [pstate typescript--ensure-cache nil typescript--backward-text-property typescript--pstate 2 function] 2 (#$ . 33508)])
#@163 Helper function for `typescript--beginning-of-defun-nested'.
If PSTATE represents a non-empty top-level defun, return the
top-most pitem.  Otherwise, return nil.
(defalias 'typescript--pstate-is-toplevel-defun #[(pstate) "\305\306\305	:\203$	@\307\n8\310=\203T\n	A\211\202	\311=\205+\f,\207" [pstate #1=#:--cl-var-- pitem func-depth func-pitem nil 0 2 function 1] 3 (#$ . 33942)])
#@117 Helper function for `typescript--beginning-of-defun'.
Return the pitem of the function we went to the beginning of.
(defalias 'typescript--beginning-of-defun-nested #[nil "\306 \307\310\307:\2037@\311	8\312=\203,\313	!\203,\314	8b\210	\307\211\202-\310\2037A\211\202\n,\206l\307\310\307\315\316!\211\203i\317\f!\211\203d\3148b\210\307\211\202e\310)\204C+\207" [#1=#:--cl-var-- pitem #2=#:--cl-var-- #3=#:--cl-var-- pstate #4=#:--cl-var-- typescript--parse-state-at-point nil t 2 function typescript--inside-pitem-p 3 typescript--backward-text-property typescript--pstate typescript--pstate-is-toplevel-defun #5=#:--cl-var-- it] 3 (#$ . 34346)])
#@54 Helper function for `typescript-beginning-of-defun'.
(defalias 'typescript--beginning-of-defun-flat #[nil "\301 \211\205\f\302@8b)\207" [pstate typescript--beginning-of-defun-raw 3] 3 (#$ . 35036)])
#@63 Value of `beginning-of-defun-function' for `typescript-mode'.
(defalias 'typescript-beginning-of-defun #[(&optional arg) "\206\303m\204;\304W\203;T	\204&\305 \306=\204#\307 \203&\310 \210\311\312\313\314#\2035\307 b\210\202db\210\202\304V\205sS`Sf\315=\203O\316u\210\307 \211\203b\n`W\203b\nb\210\202o	\203l\317 \210\202o\320 \210)\202;\207" [arg typescript-flat-functions prologue-begin 1 0 typescript-syntactic-context function typescript--function-prologue-beginning typescript-end-of-defun typescript--re-search-forward "\\_<function\\_>" nil t 125 -1 typescript--beginning-of-defun-flat typescript--beginning-of-defun-nested] 5 (#$ . 35244)])
#@126 Flush the `typescript-mode' syntax cache after position BEG.
BEG defaults to `point-min', meaning to flush the entire cache.
(defalias 'typescript--flush-caches #[(&optional beg ignored) "\206	\214~\210e)	^\211\207" [beg typescript--cache-end] 2 (#$ . 35928) nil])
(defalias 'typescript--debug '(macro . #[(&rest arguments) "\300\207" [nil] 1]))
(defalias 'typescript--ensure-cache--pop-if-ended #[(open-items paren-depth) "@\n	A@X\2033\304`S\305\"\203\306\307!\210\310`S`\311	$\210\312	\233\211`\240\210)\313A@	\"AAB)\207" [open-items top-item paren-depth #1=#:c get-text-property typescript-pend cl--assertion-failed (not (get-text-property (1- (point)) 'typescript-pend)) put-text-property typescript--pend 5 typescript--pitem-add-child] 6])
#@213 Helper function for `typescript--ensure-cache'.
Update parsing information up to point, referring to parse,
prev-parse-point, goal-point, and open-items bound lexically in
the body of `typescript--ensure-cache'.
(defalias 'typescript--ensure-cache--update-parse '(macro . #[nil "\300\207" [(progn (setq goal-point (point)) (goto-char prev-parse-point) (while (progn (setq open-items (typescript--ensure-cache--pop-if-ended open-items (car parse))) (assert (> (nth 0 parse) (typescript--pitem-paren-depth (car open-items)))) (setq parse (parse-partial-sexp prev-parse-point goal-point (typescript--pitem-paren-depth (car open-items)) nil parse)) (setq prev-parse-point (point)) (< (point) goal-point))) (setq open-items (typescript--ensure-cache--pop-if-ended open-items (car parse))))] 1 (#$ . 36695)]))
(defalias 'typescript--show-cache-at-point #[nil "\306\307!\210\310`\311\"	r\312\313!q\210p\314 \210\n\315\211\316\211\316\317 \210\320\321!\210+\211\307!\322!\210,\207" [prop default-directory #1=#:old-dir buffer-read-only buffer-file-name buffer-undo-list require pp get-text-property typescript--pstate get-buffer-create "*Help*" kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook internal-temp-output-buffer-show inhibit-modification-hooks inhibit-read-only #2=#:buf standard-output] 4 nil nil])
#@166 Split a typescript name into its dot-separated parts.
This also removes any prototype parts from the split name
(unless the name is just "prototype" to start with).
(defalias 'typescript--split-name #[(string) "\303 \304\216\305	\306\307#*\211G\310U\205\n@\311\232?\205!\312\311\n\"\211)\207" [save-match-data-internal string name match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] split-string "\\." t 1 "prototype" remove] 5 (#$ . 38049)])
(defvar typescript--guess-function-name-start nil)
#@415 Guess the name of the typescript function at POSITION.
POSITION should be just after the end of the word "function".
Return the name of the function, or nil if the name could not be
guessed.

This function clobbers match data.  If we find the preamble
begins earlier than expected while guessing the function name,
set `typescript--guess-function-name-start' to that position; otherwise,
set that variable to nil.
(defalias 'typescript--guess-function-name #[(position) "\304\212	b\210\305y\210\306\n!\203#\305\225	=\205:\307\224\211\205:\310\307!\202:\306!\205:\305\225	=\205:\307\224\211\205:\310\307!)\207" [typescript--guess-function-name-start position typescript--function-heading-3-re typescript--function-heading-2-re nil 0 looking-at 1 match-string-no-properties] 2 (#$ . 38594)])
(defalias 'typescript--clear-stale-cache #[nil "\302\212\303\304!\211\203\305\233\211\302\240\210)\202*\306`d\307#\207" [end-prop #1=#:c nil typescript--forward-text-property typescript--pend 5 remove-text-properties (typescript--pstate t typescript--pend t)] 5])
#@89 Ensures brace cache is valid up to the character before LIMIT.
LIMIT defaults to point.
(defalias 'typescript--ensure-cache #[(&optional limit) "\206`	W\205\317\306 \307\211\307\310\216\311\2110\311\21112\311\21134\311\21156\311\21178\311\2119:;<\311\211=><:\203k<@=\312=\313\"?>\203b=>B><A\211<\202G>\237+7\212\214~\210	b\210o\204\242\314`S\315\"\211\204\242\316`\315\311e$b\210o\204\242\314`S\315\"\211\204\242\317\320!\210\204\254@C\321 3`4\322 \210e}\210\311\21101\3112\323A\311\307#\203|\324\224b0\324\2251`94b\210\3253@\"3@@A@V\204\365\317\326!\210\32749@A@\3113%3`4`9W\204\334\3253@\"3@2\33038\203(
\311\202\331\332!\203\203
\333 \2115\203\203
5\307=\203V
\3341!\2115\203S
B\203V
B0\202V
\3075\311f\335=\204a
\317\336!\210\311u\210\337\3402\3410\342\343\3445\307=\203z
5\202~
\3455!&\202\331C!\203\266
\346\224b\210\347 D\350\216\333 *\205\311u\210\337\3402\3410\342\343\344\345\351\352!!\351\353!C\244&\202\354!E7F\311G\307H\311IF:\203F@GE\312G\355\">\203\331\312G\356\"!\203\324\225b\210\337\3402\3410\342G\344\345\351\352!!&I\311\211H\202	\307\203FA\211F\202\313
I-\211J\203t`94b\210\3253@\"3@@A@V\204>\317\326!\210\32749@A@\3113%3`4`9W\204%\3253@\"JB\357`S`\315$\210\202x1b\210)\202\303+b\210`94b\210\3253@\"3@@A@V\204\240\317\326!\210\32749@A@\3113%3`4`9W\204\207\3253@\"K\211L.\207" [limit typescript--cache-end #1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks buffer-modified-p t #[nil "?\205\301\302!\207" [#1# restore-buffer-modified-p nil] 2] nil plist-get :framework get-text-property typescript--pstate previous-single-property-change cl--assertion-failed open-items syntax-ppss typescript--clear-stale-cache re-search-forward 0 typescript--ensure-cache--pop-if-ended (> (nth 0 parse) (typescript--pitem-paren-depth (car open-items))) parse-partial-sexp 8 looking-at "\\_<function\\_>" typescript--forward-function-decl typescript--guess-function-name 123 (eq (char-after) 123) make-typescript--pitem :paren-depth :h-begin :type function :name typescript--split-name 3 match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] match-string-no-properties 1 2 typescript--syntactic-context-from-pstate :contexts :class-decl put-text-property orig-match-start orig-match-end orig-depth parse prev-parse-point name case-fold-search filtered-class-styles new-item goal-point end-prop typescript--class-styles #2=#:--cl-var-- style #3=#:--cl-var-- typescript-enabled-frameworks typescript--initial-pitem typescript--quick-match-re-func typescript--guess-function-name-start typescript--plain-method-re save-match-data-internal syntactic-context #4=#:--cl-var-- class-style #5=#:--cl-var-- #6=#:--cl-var-- it typescript--last-parse-pos typescript--state-at-last-parse-pos] 12 (#$ . 39673)])
#@48 Helper function for `typescript-end-of-defun'.
(defalias 'typescript--end-of-defun-flat #[nil "\303\304\305\306\304\303#\2032\307 \210\310`S\311\"\211\203-\312\n8\313=\203)\303\304\211\202.\303\202.\303)\204\203=db\210\304\202>	*\207" [#1=#:--cl-var-- #2=#:--cl-var-- it t nil typescript--re-search-forward "}" typescript--ensure-cache get-text-property typescript--pend 2 function] 5 (#$ . 42668)])
#@48 Helper function for `typescript-end-of-defun'.
(defalias 'typescript--end-of-defun-nested #[nil "\303\304!\210\305\212\306 \211\205\307!\205\310u\210\311 \210`)\305	\203.`	W\203.	b\202L\312\313\305\314#\203A\315\224b\210\316 \211\203.\n\203J\311 \202Ldb+\207" [pitem this-end found message "test" nil typescript--beginning-of-defun-nested typescript--pitem-goto-h-end -1 forward-list typescript--re-search-forward "\\_<function\\_>" t 0 typescript--forward-function-decl] 4 (#$ . 43089)])
#@57 Value of `end-of-defun-function' for `typescript-mode'.
(defalias 'typescript-end-of-defun #[(&optional arg) "\206\303o\204#\304W\203#T\305 \210\305 \210o\204\306 \210\202\304V\205^S	\2036\307 \210\202#\310 \211\203W\n`X\203W\nb\210\311\312!\210\304\224b\210\313 \210\314 \210\202Z\315 \210)\202#\207" [arg typescript-flat-functions prologue-begin 1 0 typescript-beginning-of-defun typescript-end-of-defun typescript--end-of-defun-flat typescript--function-prologue-beginning re-search-forward "\\_<function" typescript--forward-function-decl forward-list typescript--end-of-defun-nested] 3 (#$ . 43601)])
#@75 Simple implementation of `c-backward-syntactic-ws' for `typescript-mode'.
(defalias 'typescript--backward-syntactic-ws #[(&optional lim) "\214\203	d}\210`\303\n!\210`	`U?\205\202*\207" [lim pos most-negative-fixnum forward-comment] 3 (#$ . 44237)])
#@74 Simple implementation of `c-forward-syntactic-ws' for `typescript-mode'.
(defalias 'typescript--forward-syntactic-ws #[(&optional lim) "\214\203	e}\210`\303\n!\210`	`U?\205\202*\207" [lim pos most-positive-fixnum forward-comment] 3 (#$ . 44501)])
(defalias 'typescript--up-nearby-list #[nil "\214e`\300Z]`}\210\301\302!)\207" [500 up-list -1] 3])
#@59 Return non-nil iff point is in a function parameter list.
(defalias 'typescript--inside-param-list-p #[nil "\3001\"\212\301 \210\302\303!\205\304\305!\210\302\306!\206\304\305!\210\302\306!)0\207\210\307\207" [(error) typescript--up-nearby-list looking-at "(" forward-symbol -1 "function" nil] 2 (#$ . 44863)])
#@73 Return non-nil iff point is in a Dojo multiple-inheritance class block.
(defalias 'typescript--inside-dojo-class-list-p #[nil "\3021'\212\303 \210`\304y\210\305	!\205$\304\225b\205$\305\306!\205$\304\225T=*0\207\210\307\207" [list-begin typescript--dojo-class-decl-re (error) typescript--up-nearby-list 0 looking-at "\"\\s-*,\\s-*\\[" nil] 2 (#$ . 45185)])
(defalias 'typescript--syntax-begin-function #[nil "`W\203e]b\210\302\303\304!@\211\203	A@\305=\203
	\205&\306	8b)\207" [typescript--cache-end pitem nil typescript--backward-text-property typescript--pstate 0 3] 2])
#@349 If the point is in a plain string, move to the end of it.

Otherwise, don't move.  A plain string is a string which is not a
template string.  The point is considered to be "in" a string if
it is on the delimiters of the string, or any point inside.

Returns point if the end of the string was found, or nil if the
end of the string was not found.
(defalias 'typescript--move-to-end-of-plain-string #[nil "\212\306 \3078\211\205\3108\211\203]	\311=\204]\312f	=\203-`Sf\313=\204-`\202i\314\312\315\316\317	!\320Q\312\314#\203X\n\212\310\306\321\224!8)=\203T\321\224\312\211\202U\314\2041\f*\202i\312f\322>\205i\312u\210\323 ,\211\205q
b)\207" [syntax str-terminator string-start #1=#:--cl-var-- #2=#:--cl-var-- end-position syntax-ppss 3 8 96 nil 92 t re-search-forward "\\(?:[^\\]\\|^\\)\\(" string "\\)" 1 (39 34) typescript--move-to-end-of-plain-string] 5 (#$ . 45781)])
#@198 Helper function for building `typescript--font-lock-keywords'.
Create a byte-compiled function for matching a concatenation of
REGEXPS, but only if FRAMEWORK is in `typescript-enabled-frameworks'.
(defalias 'typescript--make-framework-matcher #[(framework &rest regexps) "\302\303\"\304\305\306\307\310\311	D\312BB\313\314BBEE!\207" [regexps framework apply concat byte-compile lambda (limit) when memq quote (typescript-enabled-frameworks) re-search-forward (limit t)] 8 (#$ . 46685)])
(defvar typescript--tmp-location nil)
(make-variable-buffer-local 'typescript--tmp-location)
#@218 Move forward over a typescript destructuring spec.
If FUNC is supplied, call it with no arguments before every
variable name in the spec.  Return true iff this was actually a
spec.  FUNC must preserve the match data.
(defalias 'typescript--forward-destructuring-spec #[(&optional func) "\305f\306\307\"\203N\305u\210\310	!\210\305f\311>\203\312\n!\202=\305f\313=\203+\305u\210\202
\314!\203@\n\2038\n \210\315\225b\210\316\204
\305f\317=\205\254\305u\210\316\202\254\306\320\"\205\254\305u\210\310	!\210\314\f!\203\241\315\225b\210\310	!\210\305f\321>\203w\312\n!\202\211\314!\203\241\n\203\204\n \210\315\225b\210\316\203\241\310	!\210\305f\313=\203\241\305u\210\310	!\210\202\\\305f\322=\205\254\305u\210\316)\207" [#1=#:temp most-positive-fixnum func typescript--name-re typescript--objfield-re nil eql 91 forward-comment (91 123) typescript--forward-destructuring-spec 44 looking-at 0 t 93 123 (91 123) 125] 3 (#$ . 47275)])
#@223 Font-lock matcher for variable names in a variable declaration.
This is a cc-mode-style matcher that *always* fails, from the
point of view of font-lock.  It applies highlighting directly with
`font-lock-apply-highlight'.
(defalias 'typescript--variable-decl-matcher #[(limit) "\3061 
\3071
\214e}\210\310\311\n!\210	\204%\312f\313=\205
\312u\210\311\n!\210\314!\203\355\315\211@\211\224\"
\225#\316\f8$\"\204P\317\f8\206\345\320\321
\f#\202\345\322\fA@!\211%\242\323=\203o\324\"#%AA#\210%A@%%\204$\310=\204\312\202\344$\204\233\325\"#\323\312$\206\344\326\"#\323%$\202\344$\310=\203\256\326\"#\323%$\202\344$\327=\203\301\330\"#\323%$\202\344$\331=\203\324\332\"#\323%$\202\344$\333=\205\344\334\"#\323%$)-\210\335\225b\202\367\212\336 )\205
\336\337!\205
\311\n!\210\312f\340=\203
\312u\210\341 \210\311\n!\210\312\211\202*00\202$
0\210\202%
\210\202%
\210\312\207" [limit first most-positive-fixnum typescript--name-re highlight match (end-of-buffer) (scan-error) t forward-comment nil 44 looking-at (0 font-lock-variable-name-face) 2 3 error #1="No match %d in highlight %S" eval face add-text-properties text-property-not-all put-text-property prepend font-lock-prepend-text-property append font-lock-append-text-property keep font-lock-fillin-text-property 0 typescript--forward-destructuring-spec #[nil "\306\211@\211\224	\225\3078\n\204!\3108\206\230\311\312	#\202\230\313A@!\211\242\314=\203:\315\n
AA#\210
A@
\204H\f\316=\204H\317\202\227\f\204^\320\n\314\317$\206\227\321\n\314
$\202\227\f\316=\203m\321\n\314
$\202\227\f\322=\203|\323\n\314
$\202\227\f\324=\203\213\325\n\314
$\202\227\f\326=\205\227\327\n\314
$)-\207" [highlight match start end override val (0 font-lock-variable-name-face) 2 3 error #1# eval face add-text-properties t nil text-property-not-all put-text-property prepend font-lock-prepend-text-property append font-lock-append-text-property keep font-lock-fillin-text-property] 6] 61 typescript--forward-expression start end override val] 6 (#$ . 48237)])
#@58 Reports whether point is inside a documentation comment.
(defalias 'typescript--in-documentation-comment-p #[nil "\302 \3038\205\304 \305\216\212\3068b\210\307\310!+)\207" [parse save-match-data-internal syntax-ppss 4 match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] 8 looking-at "/\\*\\*"] 2 (#$ . 50335)])
#@136 This is a helper macro that determines whether jsdoc highlighting is to be applied,
and searches for the next token to be highlighted.
(defalias 'typescript--documentation-font-lock-helper #[(re limit) "\304\305\306\n\304#\203\307 \203`\305\211\202\304\204	*\207" [#1=#:--cl-var-- #2=#:--cl-var-- re limit t nil re-search-forward typescript--in-documentation-comment-p] 4 (#$ . 50697)])
#@74 Font-lock mode matcher that finds jsdoc parameter tags in documentation.
(defalias 'typescript--jsdoc-param-matcher #[(limit) "\302	\"\207" [typescript-jsdoc-param-tag-regexp limit typescript--documentation-font-lock-helper] 3 (#$ . 51103)])
#@70 Font-lock mode matcher that finds jsdoc typed tags in documentation.
(defalias 'typescript--jsdoc-typed-tag-matcher #[(limit) "\302	\"\207" [typescript-jsdoc-typed-tag-regexp limit typescript--documentation-font-lock-helper] 3 (#$ . 51352)])
#@87 Font-lock mode matcher that finds jsdoc tags that take one argument in documentation.
(defalias 'typescript--jsdoc-arg-tag-matcher #[(limit) "\302	\"\207" [typescript-jsdoc-arg-tag-regexp limit typescript--documentation-font-lock-helper] 3 (#$ . 51601)])
#@81 Font-lock mode matcher that finds jsdoc tags without argument in documentation.
(defalias 'typescript--jsdoc-empty-tag-matcher #[(limit) "\302	\"\207" [typescript-jsdoc-empty-tag-regexp limit typescript--documentation-font-lock-helper] 3 (#$ . 51863)])
#@67 Font-lock mode matcher that finds typedoc links in documentation.
(defalias 'typescript--typedoc-link-matcher #[(limit) "\302	\"\207" [typescript-typedoc-link-tag-regexp limit typescript--documentation-font-lock-helper] 3 (#$ . 52123)])
#@76 Font-lock mode matcher that finds typedoc literal markup in documentation.
(defalias 'typescript--typedoc-literal-markup-matcher #[(limit) "\302	\"\207" [typescript-typedoc-literal-markup-regexp limit typescript--documentation-font-lock-helper] 3 (#$ . 52367)])
#@61 Font-lock mode matcher that finds tslint flags in comments.
(defalias 'typescript--tslint-flag-matcher #[(limit) "\304\305\306\n\304#\203!\307\310\311\224!8\203`\305\211\202\304\204	*\207" [#1=#:--cl-var-- #2=#:--cl-var-- typescript-tslint-flag-regexp limit t nil re-search-forward 4 syntax-ppss 1] 4 (#$ . 52636)])
#@46 Level three font lock for `typescript-mode'.
(defconst typescript--font-lock-keywords-3 (byte-code "\305\306\307\310\311\312\313\314\315\316\317B\320\321B\322\323\324BD\325\326B\327\330B\331\332B\333\334	\335Q\336BB\333\334	\335Q\337BB\340\341\342\343\334\n\344\345\n\346&\347B\341\342\343\334\n\350%\351\n\352\353R\354BB\341\342\355\n\356$\334\n\344\357R\360BB\361P\362\363\211\211FD\364\n\344Q\365\366DD\367\n\344Q\365\366DD\370	\371\fR\334	\372Q\373\374\375FD\355	\376Q	\377\201@\201AFD\257\"\207" [typescript--font-lock-keywords-2 typescript--name-re typescript--dotted-name-re typescript--basic-type-re typescript--name-start-re append (typescript--jsdoc-param-matcher (1 'typescript-jsdoc-tag t t) (2 'typescript-jsdoc-type t t) (3 'typescript-jsdoc-value t t)) (typescript--jsdoc-typed-tag-matcher (1 'typescript-jsdoc-tag t t) (2 'typescript-jsdoc-type t t)) (typescript--jsdoc-arg-tag-matcher (1 'typescript-jsdoc-tag t t) (2 'typescript-jsdoc-value t t)) (typescript--jsdoc-empty-tag-matcher (1 'typescript-jsdoc-tag t t)) (typescript--typedoc-link-matcher (0 'typescript-jsdoc-value t)) (typescript--typedoc-literal-markup-matcher (0 'typescript-jsdoc-value t)) (typescript--tslint-flag-matcher (1 font-lock-preprocessor-face t)) ("\\.\\(prototype\\)\\_>" (1 font-lock-constant-face)) "\\_<class[[:space:]]+\\(\\(?:\\sw\\|\\s_\\)+\\)" ((1 font-lock-type-face)) "\\_<extends[[:space:]]+\\(\\(?:\\sw\\|\\s_\\)+\\)" ((1 font-lock-type-face)) "\\_<implements[[:space:]]+" "\\_<\\sw+" (nil nil (0 font-lock-type-face)) "\\_<interface[[:space:]]+\\(\\(?:\\sw\\|\\s_\\)+\\)" ((1 font-lock-type-face)) "\\_<type[[:space:]]+\\(\\(?:\\sw\\|\\s_\\)+\\)" ((1 font-lock-type-face)) "\\_<enum[[:space:]]+\\(\\(?:\\sw\\|\\s_\\)+\\)" ((1 font-lock-type-face)) typescript--class-decl-matcher "\\(" "\\)\\(?:\\.\\|.*$\\)" ((goto-char (match-beginning 1)) nil (1 font-lock-type-face)) ((if (match-beginning 2) (progn (setq typescript--tmp-location (match-end 2)) (goto-char typescript--tmp-location) (insert "=") (goto-char (match-beginning 2))) (setq typescript--tmp-location nil) (goto-char (point-at-eol))) (when typescript--tmp-location (save-excursion (goto-char typescript--tmp-location) (delete-char 1))) (1 font-lock-type-face)) (typescript--class-decl-matcher (2 font-lock-type-face nil t)) typescript--make-framework-matcher dojo "^\\s-*dojo\\.declare\\s-*(\"" "\\)" "\\(?:\"\\s-*,\\s-*\\(" "\\)\\)?" ((1 font-lock-type-face t) (2 font-lock-type-face nil t)) "\\)\"\\s-*,\\s-*\\[" "[[,]\\s-*\\(" "\\)\\s-*" "\\(?:\\].*$\\)?" ((backward-char) (end-of-line) (1 font-lock-type-face)) "^\\s-*" "\\s-*[],]" "\\s-*\\(?:\\].*$\\)?" ((if (save-excursion (backward-char) (typescript--inside-dojo-class-list-p)) (forward-symbol -1) (end-of-line)) (end-of-line) (1 font-lock-type-face)) "\\_<\\(const\\|var\\|let\\)\\_>\\|" typescript--variable-decl-matcher nil "\\_<new\\_>\\s-+\\(" 1 font-lock-type-face "\\_<instanceof\\_>\\s-+\\(" "\\_<function\\_>\\(\\s-+" "\\)?\\s-*\\(<.*>\\)?\\s-*(\\s-*" "\\)\\(\\s-*).*\\)?" (backward-char) (end-of-line) (1 font-lock-variable-name-face) "\\s-*[,)]" (if (save-excursion (backward-char) (typescript--inside-param-list-p)) (forward-symbol -1) (end-of-line)) (end-of-line) (0 font-lock-variable-name-face)] 31) (#$ . 52970))
#@93 A custom predicate to help `flyspell-prog-mode' determine whether a word should be checked.
(defalias 'typescript--flyspell-mode-predicate #[nil "\303\304!\203\f\304 \210\202\305 \210\306 \205?\212\307`S!\3108\205#\3118\211\205=\312 \313\216	b\210\314 \210\315\316\317 \"\210\320\321!*+?\207" [parse string-start-pos save-match-data-internal fboundp font-lock-ensure font-lock-fontify-buffer flyspell-generic-progmode-verify syntax-ppss 3 8 match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] typescript--backward-syntactic-ws skip-syntax-backward "^-" point-at-bol looking-at "from\\|import\\s-"] 4 (#$ . 56237)])
#@66 Return whether point is inside the given pitem's header or body.
(defalias 'typescript--inside-pitem-p #[(pitem) "\301 \210\3028\204
\303\304!\210A@\204\303\305!\210`\3028V\205+\3068?\206+\3068`V\207" [pitem typescript--ensure-cache 3 cl--assertion-failed (typescript--pitem-h-begin pitem) (typescript--pitem-paren-depth pitem) 5] 3 (#$ . 56907)])
#@203 Parse the typescript program state at point.
Return a list of `typescript--pitem' instances that apply to point, most
specific first.  In the worst case, the current toplevel instance
will be returned.
(defalias 'typescript--parse-state-at-point #[nil "\212\214~\210\304 \210m\203`\202`T\212\305\306!)\206	C\307\n@\3108\311=\2048\312!\2048\n\211A\210\202)\n,\207" [bound typescript--initial-pitem pstate pitem typescript--ensure-cache typescript--backward-text-property typescript--pstate nil 2 toplevel typescript--inside-pitem-p] 2 (#$ . 57272)])
#@66 Return the typescript syntactic context corresponding to PSTATE.
(defalias 'typescript--syntactic-context-from-pstate #[(pstate) "\302@8\211\303>\203	\202	:\203\304\202\305)\207" [pstate type 2 #'macro class toplevel] 3 (#$ . 57844)])
#@119 Return the typescript syntactic context at point.
When called interatively, also display a message with that
context.
(defalias 'typescript-syntactic-context #[nil "\301\302 !\303\304!\203\305\306\"\210)\207" [syntactic-context typescript--syntactic-context-from-pstate typescript--parse-state-at-point called-interactively-p interactive message "Syntactic context: %s"] 3 (#$ . 58096) nil])
#@116 Font lock function used by `typescript-mode'.
This performs fontification according to `typescript--class-styles'.
(defalias 'typescript--class-decl-matcher #[(limit) "\306\307\306\310!\210\311\f\307#\203\214\312\225\312\224b\210
\306\211\307\306:\203w@\313\314\"\313\315\">\203j\316 \313\317\">\203j\203j\320!\203j\312\225b\210\307\306\211\202k\307\203wA\211\202*-\203\205\307\306\211\202\211b\210\307\204\n\n+\207" [orig-end #1=#:--cl-var-- #2=#:--cl-var-- limit typescript--quick-match-re typescript--class-styles nil t typescript--ensure-cache re-search-forward 0 plist-get :class-decl :framework typescript-syntactic-context :contexts looking-at #3=#:--cl-var-- style decl-re #4=#:--cl-var-- #5=#:--cl-var-- typescript-enabled-frameworks] 5 (#$ . 58500)])
#@45 Level four font lock for `typescript-mode'.
(defconst typescript--font-lock-keywords-4 (byte-code "\306\307B	\310B\n\311\312R\313\n\314Q\315\316\317FD\320\f
\321B\322B\323B\324BBB\"BBBB\207" [typescript--access-modifier-re typescript--basic-type-re typescript--name-re typescript--name-start-re typescript--font-lock-keywords-3 typescript--decorator-re ("\\(this\\)\\." (1 'typescript-this-face)) ((1 'typescript-access-modifier-face)) ((1 'typescript-primitive-face)) "\\s-*" "<\\s-*" "\\(" "\\)\\(\\s-*>[^<]*\\)?" (backward-char) (end-of-line) (1 font-lock-type-face) append ((1 font-lock-function-name-face)) ((1 font-lock-function-name-face)) ((1 font-lock-type-face)) (("\\(=>\\)" (1 font-lock-keyword-face))) typescript--function-call-re typescript--builtin-re] 10) (#$ . 59328))
#@70 Font lock keywords for `typescript-mode'.  See `font-lock-keywords'.
(defconst typescript--font-lock-keywords '(typescript--font-lock-keywords-4 typescript--font-lock-keywords-1 typescript--font-lock-keywords-2 typescript--font-lock-keywords-3 typescript--font-lock-keywords-4) (#$ . 60126))
#@58 Regular expression matching a JavaScript regexp literal.
(defconst typescript--syntax-propertize-regexp-regexp "/\\(?:[^/[\\]\\|\\\\.\\|\\[\\(?:[^]\\]\\|\\\\.\\)*]\\)*\\(/?\\)" (#$ . 60424))
(defalias 'typescript-syntax-propertize-regexp #[(end) "\303 \3048\305=\205*\3068b\210\307	!\205*\n\310\225V\203 \310\225\311\310\224\n\312\313$\210\nb)\207" [ppss typescript--syntax-propertize-regexp-regexp end syntax-ppss 3 47 8 looking-at 1 put-text-property syntax-table (7 . 47)] 5])
(defalias 'typescript-syntax-propertize #[(start end) "	\211b\210`	W\205Y\302\303	\304#\205Y\305\224\203H\306u\210\307\224f\310>\2038\212\307\224b\210\311`[!\210`Sf\312>)\203\313\305\224\305\225\314\315$\210\316	!\210\202\317\224\203\313\317\224\317\225\314\320$\210\202*\207" [start end re-search-forward "\\(?:^\\|[=([{,:;|&!]\\|\\_<return\\_>\\)\\(?:[ 	]\\)*\\(/\\)[^/*]\\|\\`\\(#\\)!" t 1 -1 0 (32 9) forward-comment (61 40 123 91 44 58 59 nil) put-text-property syntax-table (7 . 47) typescript-syntax-propertize-regexp 2 (2097163)] 6])
#@67 Regexp matching keywords optionally followed by an opening brace.
(defconst typescript--possibly-braceless-keyword-re (typescript--regexp-opt-symbol '("catch" "do" "else" "finally" "for" "if" "try" "while" "with")) (#$ . 61474))
#@76 Regexp matching keywords that affect indentation of continued expressions.
(defconst typescript--indent-keyword-re (typescript--regexp-opt-symbol '("in" "instanceof")) (#$ . 61709))
#@77 Regexp matching operators that affect indentation of continued expressions.
(defconst typescript--indent-operator-re (concat "[-+*/%<>=&^|?:.]\\([^-+*/]\\|$\\)\\|" typescript--indent-keyword-re) (#$ . 61897))
#@38 Regexp that matches number literals.
(defconst typescript--number-literal-re "\\(?:NaN\\|-?\\(?:0[Bb][01]+\\|0[Oo][0-7]+\\|0[Xx][0-9a-fA-F]+\\|Infinity\\|\\(?:[[:digit:]]*\\.[[:digit:]]+\\|[[:digit:]]+\\)\\(?:[Ee][+-]?[[:digit:]]+\\)?\\)\\)" (#$ . 62112))
#@174 These keywords cannot be variable or type names and start a new sentence.
Note that the "import" keyword can be a type import since TS2.9, so it might
not start a sentence!
(defconst typescript--reserved-start-keywords '("const" "export" "function" "let" "var") (#$ . 62375))
#@70 A regular expression matching `typescript--reserved-start-keywords'.
(defconst typescript--reserved-start-keywords-re (typescript--regexp-opt-symbol '("const" "export" "function" "let" "var")) (#$ . 62657))
#@77 Keywords/Symbols that help tell apart colon for types vs ternary operators.
(defconst typescript--type-vs-ternary-re (byte-code "\301\302\303\304\"!P\207" [typescript--reserved-start-keywords "[?]\\|" typescript--regexp-opt-symbol append ("as" "class" "interface" "private" "public" "readonly")] 5) (#$ . 62870))
#@213 Auxiliary function for `typescript--search-backward-matching-angle-bracket'.
DEPTH indicates how nested we think we are: it increases when we cross closing
brackets, and decreases when we cross opening brackets.
(defalias 'typescript--search-backward-matching-angle-bracket-inner #[(depth) "\303X\206-\304\305	P\306\307#\205-\306f\310\n\311\"\203!\312S!\202,\310\n\313\"\205,\312T!)\207" [depth typescript--reserved-start-keywords-re #1=#:temp 0 typescript--re-search-backward "[<>]\\|" nil t eql 60 typescript--search-backward-matching-angle-bracket-inner 62] 4 (#$ . 63191)])
#@279 Search for matching "<" preceding a starting ">".
DEPTH indicates how nested we think we are.  Assumes the starting position is
right before the closing ">".  Returns nil when a match was not found,
otherwise returns t and the current position is right before the matching
"<".
(defalias 'typescript--search-backward-matching-angle-bracket #[nil "\300\301!\207" [typescript--search-backward-matching-angle-bracket-inner 1] 2 (#$ . 63785)])
#@115 Search backwards, jumping over text within angle brackets.
Searches specifically for any of "=", "}", and "type".
(defalias 'typescript--re-search-backward-ignoring-angle-brackets #[nil "\300\301\302\303#\205\304\305!?\206\306 \205\307 \207" [typescript--re-search-backward "[>=}]\\|\\_<type\\_>" nil t looking-at ">" typescript--search-backward-matching-angle-bracket typescript--re-search-backward-ignoring-angle-brackets] 4 (#$ . 64232)])
#@74 Return non-nil if point is on a typescript operator, other than a comma.
(defalias 'typescript--looking-at-operator-p #[nil "\306 \307\216\310	!\205\260\310\311!\203$\212\312 \210\313\314\315\316#\205 \310\317!)\205\260\310\320!\2054\212\321 \210`Sf\322>)?\205\260\310\n!\205H\212\321 \210`Sf\323>)?\205\260\310\324!\205\222\212\325 \205\221\313\326P\315\316#\205\221\310\327!\206\221\310\330!\206\221\310\311!\203\203\313\f\315\316#\203\203\310\317!?\206\221\310\331!\205\221\332 \205\221\310\333!)?\205\260\310\334!\205\257\310\335
\336Q!\205\257\212\321 \210`Sf\337>)?*\207" [save-match-data-internal typescript--indent-operator-re typescript--indent-keyword-re typescript--keyword-re typescript--type-vs-ternary-re typescript--name-re match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] looking-at ":" backward-sexp typescript--re-search-backward "[?:{]\\|\\_<case\\_>" nil t "?" "/" typescript--backward-syntactic-ws (44 91 40) (44 123 125 59) ">" typescript--search-backward-matching-angle-bracket "[=:]\\|" "\\_<as\\_>" "\\_<import\\_>" "=" typescript--re-search-backward-ignoring-angle-brackets "\\_<type\\_>" "*" "\\* *\\(?:\\[\\|" " *(\\)" (44 125 123 59)] 4 (#$ . 64686)])
#@61 Return non-nil if the current line continues an expression.
(defalias 'typescript--continued-expression-p #[nil "\212\300 \210\301\302!?\2058\303 \2068\304 \210o\204\305u\210`eV\2058\212\305u\210\301\306!)?\2058\303 \2058\305u\210\301\307!?)\207" [back-to-indentation looking-at "\\.\\.\\." typescript--looking-at-operator-p typescript--backward-syntactic-ws -1 "[/*]/" "++\\|--\\|/[/*]"] 2 (#$ . 65937)])
#@234 Return non-nil if point is on the "while" of a do-while statement.
Otherwise, return nil.  A braceless do-while statement spanning
several lines requires that the start of the loop is indented to
the same column as the current line.
(defalias 'typescript--end-of-do-while-loop-p #[nil "\212\302 \303\216\304\305!\205[\212\306\307x\210\304\306!)\203'\212\310 \210\311\312!\210\304\313!)\202[\314\313\315 \316#\210\304\313!\206[\317 \314\320\307\316#\203F\317 	U\2037\304\321!\205Z\322\323\324 \316#?\205Z\317 	U)+\207" [save-match-data-internal saved-indent match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] looking-at "\\s-*\\_<while\\_>" "[ 	\n]*}" nil backward-list forward-symbol -1 "\\_<do\\_>" typescript--re-search-backward point-at-bol t current-indentation "^\\s-*\\_<" "\\s-*\\_<do\\_>" typescript--re-search-forward "\\_<while\\_>" point-at-eol] 4 (#$ . 66357) nil])
#@189 Helper function for `typescript--proper-indentation'.
Return the proper indentation of the current line if it starts
the body of a control statement without braces; otherwise, return
nil.
(defalias 'typescript--ctrl-statement-indentation #[nil "\212\302 \210\212\303 e=?\205F\304\305!?\205F\306\307\310\311#\210m\204!\310u\210`Sf\312U\203,\313 \210\314\315!\210\314\316!\210\304!\205F`Sf\317U?\205F\320 ?)\205T\212\321\224b\210\322 	\\))\207" [typescript--possibly-braceless-keyword-re typescript-indent-level back-to-indentation point-at-bol looking-at "[{]" typescript--re-search-backward "[[:graph:]]" nil t 41 backward-list skip-syntax-backward " " "w_" 46 typescript--end-of-do-while-loop-p 0 current-indentation] 4 (#$ . 67291)])
(defalias 'typescript--get-c-offset #[(symbol anchor) "\304BC\305\nBC!)\207" [typescript-comment-lineup-func c-offsets-alist symbol anchor c c-get-syntactic-indentation] 3])
#@478 Search backward for the start of a generic's parameter list and move to it.

This is a utility function for
`typescript--backward-to-parameter-list'.

This function must be called with the point placed on the final >
of the generic's parameter list.  It will scan backwards to find
the start.  If successful, it will move the point to the start of
the list.  If not, it does not move the point.

Returns nil on failure, or the position to which the point was
moved on success.
(defalias 'typescript--backward-over-generic-parameter-list #[nil "\301f\302=\205E\303\3042D\305V\203B\306\307\301\310#\204 \311\304\301\"\210\312\313!\2035`Sf\314=\204
T\211\202\312\315!\203
S\211\202`0)\207" [depth nil 62 1 --cl-block-search-loop-- 0 re-search-backward "[<>]" t throw looking-at ">" 61 "<"] 5 (#$ . 68219)])
#@679 Search backward for the end of a parameter list and move to it.

This is a utility function for `typescript--proper-indentation'.

This function must be called with the point placed before an
opening curly brace.  It will try to skip over the type
annotation that would mark the return value of a function and
move to the end of the parameter list.  If it is unsuccessful, it
does not move the point. "Unsuccessful" here also means that
the position at which we started did not in fact mark the
beginning of a function. The curly brace belonged to some other
syntactic construct than a function.

Returns nil on failure, or the position to which the point was
moved on success.
(defalias 'typescript--backward-to-parameter-list #[nil "\212\3032\233\304 \210`Sf\305=\203$\306u\210\307\310!\210`Sf\311=\203$\312\303`\"\210\313\314`\315Z\"\2033\316u\210\202`Sf\317=\203D\306u\210\320 \210\202`Sf\321>\203R\306u\210\202`Sf\322>\204l\313\323\"\203~\212\306v\210\324\325!)\204~\3261v\327 0\202z\210\202\210\202\313	\212\330\331\323\332#)\332#\203\223\333\224b\210\202\312\303\323\"\210\202)\206\253\304 \210`Sf\311=\205\253`\211\205\262\nb)\207" [typescript--dotted-name-re typescript--number-literal-re location --cl-block-search-loop-- typescript--backward-syntactic-ws 58 -1 skip-syntax-backward " " 41 throw looking-back "=>\\|is" 2 -2 62 typescript--backward-over-generic-parameter-list (124 46) (41 125 34 93) nil looking-at "\\_<\\(switch\\|if\\|while\\|until\\|for\\)\\_>\\(?:\\s-\\|\n\\)*(" (scan-error) backward-sexp re-search-backward "\\(?:\\s-\\|\n\\)" t 0] 7 (#$ . 69047)])
#@53 Return the proper indentation for the current line.
(defalias 'typescript--proper-indentation #[(parse-status) "\212\306 \210\3078\203\310\311\3128\"\202\325\3128\203\313\202\325\314 \206\325\315f\316=\203-\313\202\325A@\203\307\317\320!\317\321!\322 A@	b\210\317\323!\203\267\324\325!\210\326 \204\\`Sf\327=\203b\330 \210\202l\331\332\315\"\204l	b\210\306 \210\f?\205w\317\333!\f\206\201\205\201
\211\203\212i\202\236\n\203\232\334i\335_ #\202\236i\\!
\203\261\"\203\261!\\\202\263!+\202\303\f\204\302\315u\210\336\315w\210i,\202\325\322 \203\324 \\\202\325\313)\207" [parse-status list-start continued-expr-p switch-keyword-p same-indent-p in-switch-p back-to-indentation 4 typescript--get-c-offset c 8 0 typescript--ctrl-statement-indentation nil 35 looking-at "[]})]" "\\_<default\\_>\\|\\_<case\\_>[^:]" typescript--continued-expression-p "[({[]\\s-*\\(/[/*]\\|$\\)" skip-syntax-backward " " typescript--backward-to-parameter-list 41 backward-list looking-back "," "\\_<switch\\_>" + 2 " 	" typescript-indent-level typescript-expr-indent-offset indent typescript-indent-switch-clauses] 5 (#$ . 70666)])
#@40 Indent the current line as typescript.
(defalias 'typescript-indent-line #[nil "\214~\210\212\302\303 !)i\304 Z\305\306!!\210	\307V\205!\310	\304 \\!+\207" [parse-status offset syntax-ppss point-at-bol current-indentation indent-line-to typescript--proper-indentation 0 move-to-column] 3 (#$ . 71836) nil])
#@45 Fill the paragraph with `c-fill-paragraph'.
(defalias 'typescript-c-fill-paragraph #[(&optional justify) "\306\307\310K\311K\312\216\310	M\210\311M\210\313\211
!.\207" [#1=#:vnew #2=#:vnew #3=#:old #4=#:old fill-paragraph-function justify #[(&optional limit) "\301!\207" [limit typescript--forward-syntactic-ws] 2] #[(&optional limit) "\301!\207" [limit typescript--backward-syntactic-ws] 2] c-backward-sws c-forward-sws #[nil "\302M\210\303	M\207" [#3# #4# c-backward-sws c-forward-sws] 2] c-fill-paragraph] 3 (#$ . 72153) "*P"])
(defalias 'typescript--pitem-format #[(pitem) "\3038\3048\305\306\n	:\204	\202\307	\310\"#*\207" [pitem type name 4 2 format "name:%S type:%S" plist-get :name] 6])
#@201 Helper function for `typescript--splice-into-items'.
Return a new item that is the result of merging CHILD into
ITEM.  NAME-PARTS is a list of parts of the name of CHILD
that we haven't consumed yet.
(defalias 'typescript--make-merged-item #[(item child name-parts) "\3048:\204!\305\306C\307\304	8:\204\n\202\304	8\310\311!&A\2030\312@	A#\202D\304	8:\204>	@B\202D\313	@@\"AB\207" [item child typescript--dummy-class-style name-parts 2 make-typescript--pitem :children :type :name typescript--pitem-strname typescript--splice-into-items append] 8 (#$ . 72873)])
#@56 Last part of the name of PITEM, as a string or symbol.
(defalias 'typescript--pitem-strname #[(pitem) "\3028\211:\203\303	!@\202	)\207" [pitem name 4 last] 3 (#$ . 73460)])
#@230 Splice CHILD into the `typescript--pitem' ITEMS at NAME-PARTS.
If a class doesn't exist in the tree, create it.  Return
the new items list.  NAME-PARTS is a list of strings given
the broken-down class name of the item to insert.
(defalias 'typescript--splice-into-items #[(items child name-parts) "@	\306\211\211\211\211;\204\307\310!\210G\311V\204$\307\312!\210\203o\313@!\232\203Q\314@#AB\f\203L\f\241\210\202o\202o@\306B\f\203b\f\241\210\202dA\211\204$\203x
\202\225A\203\221\315\316\317\306A#\320\321&\202\223	B.\207" [name-parts items item new-cons last-new-item new-items nil cl--assertion-failed (stringp top-name) 0 (> (length top-name) 0) typescript--pitem-strname typescript--make-merged-item make-typescript--pitem :children typescript--splice-into-items :type :name item-ptr top-name child typescript--dummy-class-style] 8 (#$ . 73646)])
#@75 Copy `typescript--pitem' PITEM, and push CHILD onto its list of children.
(defalias 'typescript--pitem-add-child #[(pitem child) "\3068\250\204\307\310!\210\3118:\2039\3118\312\313	:\2030	@\211;\211\2030	A\211\202\2055\313+\202:\313\204A\307\314!\210\3118\3158\211\243\203X\316@
#\202|\f:\203w\317\f\320\"\203w
:\204m\307\321!\210\316@
#\202|@B*AB\207" [child #1=#:--cl-var-- part #2=#:--cl-flag-- type name 3 cl--assertion-failed (integerp (typescript--pitem-h-begin child)) 4 nil t (if (consp (typescript--pitem-name child)) (loop for part in (typescript--pitem-name child) always (stringp part)) t) 2 typescript--splice-into-items plist-get :prototype (consp name) pitem] 5 (#$ . 74571)])
#@42 Regexp to match errors generated by tsc.
(defconst typescript-tsc-error-regexp "^[[:blank:]]*\\([^(
\n)]+\\)(\\([0-9]+\\),\\([0-9]+\\)):[[:blank:]]+error [[:alnum:]]+: [^
\n]+$" (#$ . 75310))
#@42 Regexp to match errors generated by tsc.
(defconst typescript-tsc-pretty-error-regexp "^[[:blank:]]*\\([^(
\n)]+\\):\\([0-9]+\\):\\([0-9]+\\) - [[:blank:]]*error [[:alnum:]]+: [^
\n]+$" (#$ . 75508))
#@46 Regexp to match reports generated by tslint.
(defconst typescript-tslint-report-regexp "^[[:blank:]]*\\(?:\\(?:ERROR\\|\\(WARNING\\)\\):[[:blank:]]+\\)?\\((.*)[[:blank:]]+\\)?\\([^(
\n)]+\\)\\[\\([[:digit:]]+\\), \\([[:digit:]]+\\)\\]: .*$" (#$ . 75714))
(byte-code "\305\306BB\307	\310BB\311\n\312BBE\313\211\203,\f@\314\315\"\210\314\316@\"\210\fA\211\204*\313\207" [typescript-tsc-error-regexp typescript-tsc-pretty-error-regexp typescript-tslint-report-regexp regexp --dolist-tail-- typescript-tsc (1 2 3 2) typescript-tsc-pretty (1 2 3 2) typescript-tslint (3 4 5 (1)) nil add-to-list compilation-error-regexp-alist-alist compilation-error-regexp-alist] 6)
(defvar typescript-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [typescript-mode-hook variable-documentation put "Hook run after entering typescript mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp typescript-mode-map definition-name typescript-mode] 4)
(defvar typescript-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\312\300\313\"\210!\210\300\302N\2041\303\300\302\304\314!#\210\303\310\315\316#\210\303\310\317\320#\207" [typescript-mode-abbrev-table typescript-mode-map variable-documentation put purecopy "Keymap for `typescript-mode'." boundp definition-name typescript-mode (lambda (#1=#:def-tmp-var) (defvar typescript-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `typescript-mode'." derived-mode-parent prog-mode custom-mode-group typescript] 5)
#@249 Major mode for editing typescript.

Key bindings:

\{typescript-mode-map}

In addition to any hooks its parent mode `prog-mode' might have run,
this mode runs the hook `typescript-mode-hook', as the final or penultimate step
during initialization.
(defalias 'typescript-mode #[nil "\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\306\325!\210\326\306\327!\210\330\306\331!\210\332\306\333!\210\334\306\335!\210=C\306\336!\210\337\306\340!\210\307 \306\341!\210\307!\306\342!\210\343\"\306\344!\210\345$\306\346!\210\347&\350\351\352\307\211$\210\353 \210\354>\355\211?@\356A\357B\360C\361D\307E\306\362!\210\306\363!\210\306\364!\210\306\365!\210\306\366!\210\367 \210)\306\370!\210\3718)\372\373!\207" [delay-mode-hooks major-mode mode-name typescript-mode-map typescript-mode-abbrev-table local-abbrev-table make-local-variable t prog-mode typescript-mode "typescript" mode-class put keymap-parent set-keymap-parent current-local-map abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table indent-line-function typescript-indent-line beginning-of-defun-function typescript-beginning-of-defun end-of-defun-function typescript-end-of-defun open-paren-in-column-0-is-defun-start nil font-lock-defaults syntax-propertize-function typescript-syntax-propertize parse-sexp-ignore-comments parse-sexp-lookup-properties comment-start "// " comment-end "" fill-paragraph-function typescript-c-fill-paragraph add-hook before-change-functions typescript--flush-caches typescript--update-quick-match-re "//+\\|\\**" "$" "* " "//" "/[*/]\\|\\s!" "\\(//+\\|/\\*+\\)\\s *" paragraph-start paragraph-separate paragraph-ignore-fill-prefix adaptive-fill-mode adaptive-fill-regexp c-setup-paragraph-variables syntax-begin-function typescript--syntax-begin-function run-mode-hooks typescript-mode-hook typescript-mode-syntax-table typescript--font-lock-keywords c-comment-prefix-regexp c-paragraph-start c-paragraph-separate c-block-comment-prefix c-line-comment-starter c-comment-start-regexp comment-start-skip c-buffer-is-cc-mode] 6 (#$ . 77408) nil])
(byte-code "\300\301\302\303#\210\304\305\306\"\210\307\310\311\"\210\312\301!\207" [put typescript-mode flyspell-mode-predicate typescript--flyspell-mode-predicate eval-after-load folding #[nil "\300\301!\205\301\302\303\304#\207" [fboundp folding-add-to-marks-list typescript-mode "// {{{" "// }}}"] 4] add-to-list auto-mode-alist ("\\.ts$" . typescript-mode) provide] 4)