EcmaScript Sublime Syntax

适用于EcmaScript / Javascript / ES6 / ES2015 / Babel等语言的Sublime语法定义。

Sublime语法仅在Sublime Text 3.0中可用。

2.5版本新增

新增

• 逻辑赋值运算符 &&=，??=（||= 已经存在）
• 私用字段品牌检查的可定制的用法（《#foo in bar》）
• 类静态块
• 导入断言

删除

• 旧绑定运算符提案（《::》）已经死亡多年，无法继续保留。再见，老朋友——你其实很酷。
• 范围 keyword.operator.assignment.conditional.mallet 已更改，以与其他扩展赋值运算符的约定对齐。

修复

• 私用生成器方法不再导致类体上下文在类体实际结束时继续存在。

在1.6版本中新增加

• 嵌套语法高亮显示

多行模板字面量的一个常见用途是在其中嵌入代码片段。例如，浏览器中的HTML/CSS片段或node.js中的SQL查询。对于较长的模板字面量，启用嵌套语法高亮显示可能有助于使代码片段更容易阅读。您可以通过在模板字面量之前添加一个块注释指令来启用此功能。该指令的完整语法如下

/* syntax: {SYNTAX_NAME} */ tag? `contents`

其中，tag标识符可以出现在语法块注释指令之前或之后。

使用此指令的一个好处是嵌套语法块将从它们自己的语法定义中继承它们通常的功能，例如键绑定、片段、自动完成和注释

支持的语法：以下是当前支持的语法列表。我选择了假设在浏览器/Node.js中合理使用的所有语法。如果您认为另一种语法会有用，请随意提交一个问题。

• bash | shell
• css
• html
• javascript | js
• json
• dot (Graphviz)
• glsl (GLslang for WebGL)
• lua
• sql
• xml
• yaml

以下是当前支持的语法演示

新版本 1.3

• 改进 JSX 范围
• 支持 JSX 片段
• 支持样式 JSX
• 支持数字分隔符
• 支持 BigInt
• 正则表达式特性：dotall 标志、属性转义、命名捕获以及后视匹配
• 私有实例字段

样式 JSX 的添加需要一些解释。之前我半心半意地通过将具有模板子元素的 JSX 元素委托给 CSS 语法定义来实现，这在实际使用中效果不佳，因为默认 CSS 语法定义中的匹配具有上下文敏感性——也就是说，在插值后的任何位置，CSS 的着色可能会出现问题，因为它不再知道它是在选择器中还是值中等。

为了解决这个问题，我添加了一个故意宽宏大量且不精确的简单（扁平）CSS 匹配器，它主要关注识别此上下文中的词法构造。它使用与预打包的 sublime CSS 定义相同的范围名称的子集，但由于失去了上下文意识，某些范围需要合并。最终结果是，尽管失去了区分，但对于绝大多数情况，样式 JSX 模板的颜色突出显示应该是一致的且有帮助。

JSX 中已移除对 XML 风格命名空间（ns 冒号）的支持。它在官方语法中存在，但据我们所知，在实际中并未使用，也不受 Babel 的 JSX 转换支持。相反，改善了成员表达式样式组件名称的范围，并将 html（小写/可能带有连字符）名称与组件引用（大写字母/ ES 标识符）区分开来。

JSX 片段是一种指示不带有额外 div 的无键兄弟节点组的新方式：`<>>stuff<>`。

允许在大多数位置使用下划线作为数位字的数学分隔符提议，最近已经推进到第 3 阶段。

BigInt 提案也是如此。这是一种新的数字类型，其通过在数字字面量后添加“n”后缀来表示。

第 3 阶段的新正则表达式功能包括 dotall（“s”）标志、Unicode 属性字符类转义、命名捕获组和命名捕获反转引用，以及正向和负向后视断言。

包括私有实例字段（以“#”为前缀），需要注意，由于实际原因，我们的定义不能识别大多数此类属性引用将非法的情况。

虽然不是非常彻底，但一些颜色方案已进行了一点点更新，以利用新的范围。（如果有人有所贡献，我们总是在寻找更好的颜色方案！）

新版本 1.1

• 大多数目前处于第 3 阶段的提议（可能是 ES2018）以及一些第 2 阶段的提议现在已经覆盖。
• 添加了新的主题，Haydn

新版本 1.0

• 对合并冲突标记的支持（由于其本身的性质而不能完美实现，但总比没有好）
• 新主题，Sibelius，这可能是第一个合适的主题。鉴于它已经存在一年，错误似乎得到了控制，相当多的人正在使用它，我觉得我该发布“1.0”了。

新版本 0.3

• 支持 JSX
• 在根目录添加 source.js 以提高与其他包的兼容性

新版本 0.2

• “Villa-Lobos”主题
• 异步函数/方法/箭头作用域与生成器同理
• Promise及其方法具有独特的作用域
• 每个链接添加了"todo"作用域

• 各种小的修复，例如允许数组字面量中有多个展开

  • 剩余工作
  • 为何要这样做
  • 特性覆盖
  • 非JavaScript扩展
  • SublimeText符号
  • 主题
  • 作用域
  • “官方”作用域
  • 符号辅助作用域
  • 互操作性作用域
  • 嵌套语法作用域
  • 关于作用域惯例
  • 更多关于作用域定义本身的信息
  • 为什么它如此庞大？
  • 几乎与表达式相关的所有内容为什么都出现了两次？
  • 一个复杂的上下文转换网络会降低高亮效率吗？
  • 如何破坏它？

剩余工作

• 我想在定义包中提供更多主题。其中之一是“Excelsior”，这是一种尝试展示可以实现什么的很糟糕的尝试，但随着其成熟，我非常喜欢它。现在它（大部分）已经完整。然而，对于许多用户来说，这可能有点过多。
• 从assignmentExpression_NO_IN开始的以注释分隔的代码块实际上可以作为构建步骤生成。这样做将降低在未对应更改assignmentExpression_NO_IN的情况下意外编辑assignmentExpression的可能性。我不确定这是否值得，但它在我脑海中辗转反侧。
• 许多看似冗余的上下文存在是有好理由的——但并非所有。应该有一个上下文清理和合并阶段，但更重要的是，对于模式或更常见的模式组件。

为何要这样做

目前为JavaScript提供了至少三种tmLanguage语法定义，其中两种支持ES6+：JSNext和Babel Sublime（我认为它是前者的分支）。由于它们实际上已经很好了，所以我应该解释一下这个第四个的作用。

Sublime语法是一个全新的YAML语法定义系统，它在2015年4月的Sublime Text dev构建3084中首次引入。之前Sublime支持的唯一定义系统是tmLanguage，最初来自TextMate。除了裁剪出常见的 YAML -> heinous XML的构建步骤外，Sublime语法还引入了一个“上下文”系统来控制在给定时刻可以进行何种类型的匹配。

上下文存在于FILO栈中。它们可以被推入、弹出或“设置”（弹出-推入）。正如在tmLanguage中，匹配不能超越当前行，但使用上下文可以绕过一些旧约束的后果，从而允许更高级和准确的作用域分配。

我创建这个的主要原因之一是，我很烦恼语法中许多看似相似但实际不同的元素必须共享通用作用域，如meta.brace.curly。多亏了Sublime语法，EcmaScript Sublime不需要那些描述某物如何看起来的作用域。在括号的情况下，您会发现用于块语句、对象字面量、对象绑定模式、类和函数体、命名空间导入等的作用域——括号所代表的事物。

它还超出了这一点。如果您愿意，您可以对if语句与循环语句等不同地进行着色。生成器、方法和访问器也是区分开的。实际上，有比任何合理使用过的更具体的范围，但关键是允许主题设计师选择哪些元素共享颜色（大多数良好主题实际上具有相对较小的调色板）。

然而，有合理的原因你可以更喜欢其他选择进行语法高亮。首先，也许你喜欢与之一起更好地工作的主题。还有，对于采取的方法可能更适合或不适合你的风格。最后，EcmaScript Sublime在本质上是相当严格的，因此无效的令牌序列通常不会被忽视——你可能觉得这很有用，或者你可能觉得这很麻烦。

这是Excelsior的一个早期截图。我应该很快添加一个更新的一个。

以下是一个我喜欢的一个例子，使用背景颜色来表示正则表达式匹配组的深度

特性覆盖

ECMAScript Sublime 尝试与编辑器草案的 ES 规范保持一致，并引入新语法的任何阶段 4 提案。

早期阶段的语法更改提案在很多情况下都得到了支持。如果一项提案被撤回，我们最终也会在这里移除它。要包含在阶段4之前，以下组合中的某些条件必须成立（但这并非一门科学）

• 一个或多个引擎已实现它
• 语法是该提案的一个相对明确的方面
• 它足够明确，以至于我们不会只猜测
• 该提案有很高的势头/使用率，且语法不太可能改变
• 范围足够小，以至于添加或删除它不会造成太大成本

一些于2021年中之前支持的早期阶段的提案

• 类静态块
• 装饰器
• do表达式
• function.sent元属性
• hashbang语法
• import断言
• 管道运算符
• export default from

非JavaScript扩展

除了对某些命名模板字符串的特殊处理外，唯一支持的语法特性既不是JS也不是提议中的JS，那就是JSX。这是由于其流行度、低复杂性（尤其是就其“可隔离性”而言）以及与真正的JS新语法特性碰撞的可能性不大。它是“安全的”

不支持TypeScript。它是一门独立的语言，值得有独立的语法定义。TS语法扩展几乎触及了每个生产阶段，许多出现在“不安全”的位置，这使得ES Sublime的签名特性——其相对较高的特异性——很难保留。

此外，尽管其规模很大，但其语法似乎没有明确规定！当我最初研究其可行性时，我想这很令人惊讶。我确实找到了早期尝试形式化它的证据，但与当前的TS有很大不同（而且也不是合理的）。

SublimeText符号

Sublime语法定义涉及的不仅仅是定义本身。这些其他项目使用tmPreferences格式来描述自动缩进的工作方式，以及如何填充“符号列表”。

如果你之前没有使用过Sublime符号导航，我推荐你去试试。它是通过键盘快捷键快速导航本地文件或所有打开文件的快捷方法（本地是ctrl+r，全局是shift+ctrl+r）。

在Ecmascript Sublime中，函数、生成器和类声明将出现在Sublime的符号列表中，以及默认导出。它还会拾取具有名称或作为var、let或const语句部分直接分配的函数、生成器和类表达式。在这种情况下，它将显示表达式所绑定变量的名称，这包括箭头函数。

请注意，只有出现在变量或常量声明初始化器中的表达式会被添加到列表中，所以const x = () => {}被添加为‘arrow x’，但x = () => {}则不会。

所有这些都限于本地，除了类。如果人们希望其他项也是全局的（明显除了默认导出），我们可以更改这一点。这是我觉得有意义的事情，但我几乎只在本地列表中使用，所以我不确定习惯于全局用户会想看到什么。

主题

目前有四个

• Carthage（呃）
• Excelsior（最详尽；我喜欢它，但太多了）
• Sibelius（最合理）
• Villa-Lobos（还好）

截至版本0.1.2，我还添加了许多额外的作用域，并对多项事物进行调整以提高与现有主题的互操作性。Monokai、Cobalt和Brogrammer是我的参考主题；目标是使它们尽可能接近使用Babel Sublime时的外观。由于某些可能是哲学上的差异，有一些事情无法制作匹配，但使用Ecmascript Sublime应该可以与几乎所有主题一起使用而不会感到厌恶。

如果您想为您的主题添加对 Ecmascript Sublime 的支持，或者正在开发考虑这一点的全新主题，您可能需要一个目标范围列表...

作用域

不言而喻，这些中只有少数将对大多数主题开发者真正有用；另一方面，您有权决定哪一些是。

“官方”作用域

这些通常用于目标定位的范围。为了提高可读性，我已经省略了各种标点符号的后缀“.es”以及“语法.begin.es”和“.end.es”，因为这些仅用于调试。请注意，以“.regexp”结尾的范围不具有“.es”。

• 注释 & 去向
  • comment
  • comment.block
  • comment.line
  • comment.line.shebang (例如：#!/usr/bin/env node)
  • comment.line.todo (匹配注释中的“todo”和“hack”等词)
  • meta.comment.body (不属于分隔符或边界的文本内容)
  • meta.comment.border (包括似乎像边界的任何内容以及//)
  • meta.comment.box-drawing (可针对方框绘制字符)
  • meta.directive.use-strict (使用严格指令'use strict')
  • punctuation.definition.comment (分隔符//、/*或*/)
• 常量 & 文字
  • 通用
  • constant
  • constant.language
  • constant.language.boolean
  • constant.language.boolean.false
  • constant.language.boolean.true
  • constant.language.null
  • constant.language.undefined
  • 数组
  • punctuation.definition.array
  • punctuation.separator.array-element
  • 数字
  • constant.language.infinity
  • constant.language.nan
  • constant.numeric
  • constant.numeric.binary
  • constant.numeric.decimal
  • constant.numeric.hexadecimal
  • constant.numeric.octal
  • meta.numeric.exponent.digit
  • meta.numeric.exponent.e
  • meta.numeric.exponent.sign
  • meta.numeric.prefix (0x, 0b, 0o)
  • meta.numeric.suffix (BigInt中的'n'；可能在未来扩展)
  • punctuation.decimal
  • 对象
  • punctuation.definition.object (例如let x = { a: 1 }中的大括号)
  • punctuation.separator.key-value (例如let x = { a: 1 }中的冒号及类属性提案中的等号)
  • punctuation.separator.object-member (属性之间的逗号)
  • variable.other.readwrite.property.object-literal
  • variable.other.readwrite.property.object-literal.allCap
  • variable.other.readwrite.property.object-literal.initCap
  • variable.other.readwrite.property.shorthand
  • variable.other.readwrite.property.shorthand.allCap
  • variable.other.readwrite.property.shorthand.initCap
  • variable.other.readwrite.property.shorthand.rest
  • variable.other.readwrite.property.shorthand.rest.allCap
  • variable.other.readwrite.property.shorthand.rest.initCap
  • 有关访问器和方法的说明，请参阅函数
  • 正则表达式
  • constant.character.escape.control-char.regexp
  • constant.character.escape.hexadecimal.regexp
  • constant.character.escape.null.regexp
  • constant.character.escape.pointless.regexp
  • constant.character.escape.regexp
  • constant.character.escape.unicode.regexp
  • constant.other.character-class.predefined.regexp
  • constant.other.character-class.set.regexp
  • constant.other.character-class.unicode-property-name.regexp
  • constant.other.character-class.unicode-property-value.regexp
  • keyword.control.anchor.regexp
  • keyword.operator.negation.regexp
  • keyword.operator.or.regexp
  • keyword.operator.quantifier.regexp
  • keyword.other.back-reference.regexp
  • meta.group.assertion.negative.regexp
  • meta.group.assertion.positive.regexp
  • meta.group.capturing.regexp
  • meta.group.non-capturing.regexp
  • meta.character-property.regexp
  • punctuation.definition.assertion.negative.regexp
  • punctuation.definition.assertion.positive.regexp
  • punctuation.definition.character-class.dash.regexp
  • punctuation.definition.character-class.regexp
  • punctuation.definition.character-property.regexp
  • punctuation.definition.string.regexp
  • punctuation.definition.group.capturing.regexp
  • punctuation.definition.group.non-capturing.regexp
  • punctuation.separator.character-property-name-value.regexp
  • string.regexp
  • string.regexp.flags
  • variable.other.named-capture.regexp
  • 字符串
  • constant.character
  • constant.character.escape
  • constant.character.escape.hexadecimal (例如：'\\x41')
  • constant.character.escape.newline (换行终止的反斜杠)
  • constant.character.escape.null (例如：'\\0')
  • constant.character.escape.pointless (不必要的转义)
  • constant.character.escape.unicode (例如，'\\u0041' 或 '\\u{41}')
  • 标点符号定义字符串
  • 标点符号定义内插字符串
  • 标点符号定义内插字符串元素
  • 标点符号定义引号字符串
  • 标点符号定义双引号字符串
  • 标点符号定义双引号字符串参数
  • 标点符号定义单引号字符串
  • 标点符号定义单引号字符串参数
  • 字符串
  • 内插字符串
  • 引号字符串
  • 双引号字符串
  • 单引号字符串
• 函数与函数相关
  • 通用
  • 参数
    • 实体其他属性绑定参数
    • 关键字其他剩余参数
    • 关键字其他剩余
    • 标点符号定义数组分隔绑定参数
    • 标点符号定义对象成员分隔绑定参数
    • 标点符号分隔数组元素绑定参数
    • 标点符号分隔对象成员绑定参数
    • 标点符号分隔参数
    • 标点符号分隔属性绑定参数
    • 变量参数
    • 变量参数剩余
  • 执行与Do表达式
    • keyword.control.do-expression.do (关键字来自ES7，非循环)
    • 装饰器参数
    • meta.instantiation (应用于正在实例化的标识符)
    • meta.invocation (应用于正在调用的标识符)
    • punctuation.definition.arguments (调用/实例化时括号)
    • punctuation.definition.block.do-expression (do表达式中括号)
    • punctuation.separator.argument (参数中的逗号)
    • variable.other.readwrite.tag (在foo`str${ exp }`中的foo)
  • 类型
  • 存取器
    • entity.name.accessor.get (存取器名称)
    • entity.name.accessor.set (存取器名称)
    • keyword.control.flow.return.accessor (不确定为什么我给了它一个单独的)
    • 标点符号定义存取器
    • 标点符号定义存取器主体 (大括号)
    • 标点符号定义存取器参数 (set中的param id)
    • 标点符号定义存取器参数 (括号)
    • storage.modifier.accessor.get (关键字 get)
    • storage.modifier.accessor.set (关键字 set)
  • 异步函数
    • entity.name.method.async (异步函数名称)
    • entity.name.method.private.async
    • entity.name.function.async
    • entity.name.function.async.arrow
    • keyword.control.flow.await (关键字 await)
    • 标点符号定义异步函数
    • 标点符号定义异步函数箭头
    • 标点符号定义异步函数箭头主体
    • 标点符号定义函数主体
    • 标点符号定义异步方法主体
    • 标点符号定义私有异步方法主体
    • 标点符号定义异步函数参数
    • 标点符号定义异步函数箭头参数
    • 标点符号定义异步方法参数
    • 标点符号定义私有异步方法参数
    • storage.modifier.async (关键字 async，通用)
    • storage.modifier.async.expression (关键字 async，在表达式中)
    • storage.modifier.async.method (关键字 async，在方法声明中)
  • 类
    • entity.name.class
    • entity.name.constructor
    • meta.decorator
    • meta.decorator.parenthesized
    • meta.super-expression
    • 标点符号定义类主体
    • 标点符号定义类主体块
    • 标点符号定义构造函数主体
    • 标点符号定义装饰器
    • 标点符号定义私有方法主体
    • 标点符号定义构造函数参数
    • 标点符号定义属性终止符
    • storage.modifier.extends
    • storage.modifier.static
    • storage.type.class
    • storage.type.class.expression
    • variable.other.readwrite.property.class.es
    • variable.language.private
    • variable.language.private.class
  • 函数
    • entity.name.function
    • entity.name.function.arrow
    • entity.name.function.allCap
    • entity.name.function.initCap
    • entity.name.method
    • entity.name.method.private
    • keyword.control.flow.return
    • 标点符号定义函数
    • 标点符号定义函数箭头主体
    • 标点符号定义函数主体
    • 标点符号定义方法
    • 标点符号定义方法主体
    • 标点符号定义参数
    • 标点符号定义函数参数
    • 标点符号定义函数箭头参数
    • 标点符号定义方法参数
    • 标点符号定义私有方法参数
    • storage.type.function.arrow
    • storage.type.function.async
    • storage.type.function.async.arrow
    • storage.type.function.async.expression
    • storage.type.function
    • storage.type.function.expression
  • 生成器
    • entity.name.function.generator
    • entity.name.method.generator
    • keyword.control.flow.yield.iterate
    • keyword.control.flow.yield
    • 标点符号定义生成器
    • 标点符号. 定义. 生成器. 主体
    • 标点符号. 定义. 方法. 生成器
    • 标点符号. 定义. 方法. 生成器. 主体
    • 标点符号. 定义. 参数. 生成器
    • 标点符号. 定义. 参数. 方法. 生成器
    • 存储. 修饰符. 生成器. 星号
    • 存储. 修饰符. 生成器. 星号. 表达式
    • 存储. 修饰符. 生成器. 星号. 方法
    • 存储. 类型. 函数. 生成器
    • 存储. 类型. 函数. 生成器. 表达式
• 运算符
  • 赋值
  • 通用
    • 关键字. 运算符. 赋值
    • 关键字. 运算符. 赋值. 条件
    • 关键字. 运算符. 赋值. 条件. 默认 (默认初值器)
    • 关键字. 运算符. 单一. 删除
  • 增强型
    • 关键字. 运算符. 赋值. 增强型
    • 关键字. 运算符. 赋值. 增强型. 算术
    • 关键字. 运算符. 赋值. 增强型. 算术. 加法
    • 关键字. 运算符. 赋值. 增强型. 算术. 除法
    • 关键字. 运算符. 赋值. 增强型. 算术. 指数
    • 关键字. 运算符. 赋值. 增强型. 算术. 取模
    • 关键字. 运算符. 赋值. 增强型. 算术. 乘法
    • 关键字. 运算符. 赋值. 增强型. 算术. 减法
    • 关键字. 运算符. 赋值. 增强型. 位运算
    • 关键字. 运算符. 赋值. 增强型. 位运算. 逻辑
    • 关键字. 运算符. 赋值. 增强型. 位运算. 逻辑. 与
    • 关键字. 运算符. 赋值. 增强型. 位运算. 逻辑. 或
    • 关键字. 运算符. 赋值. 增强型. 位运算. 逻辑. 异或
    • 关键字. 运算符. 赋值. 增强型. 位运算. 移位
    • 关键字. 运算符. 赋值. 增强型. 位运算. 移位. 左
    • 关键字. 运算符. 赋值. 增强型. 位运算. 移位. 右
    • 关键字. 运算符. 赋值. 增强型. 位运算. 移位. 无符号右
    • 关键字. 运算符. 赋值. 增强型. 逻辑. 与
    • 关键字. 运算符. 赋值. 增强型. 逻辑. 或
    • 关键字. 运算符. 赋值. 增强型. 逻辑. 或. 空合并
  • 位运算
  • 关键字. 运算符. 位运算
  • 关键字. 运算符. 位运算. 逻辑
  • 关键字. 运算符. 位运算. 逻辑. 与
  • 关键字. 运算符. 位运算. 逻辑. 非
  • 关键字. 运算符. 位运算. 逻辑. 或
  • 关键字. 运算符. 位运算. 逻辑. 异或
  • 关键字. 运算符. 位运算. 移位
  • 关键字. 运算符. 位运算. 移位. 左
  • 关键字. 运算符. 位运算. 移位. 右
  • 关键字. 运算符. 位运算. 移位. 无符号右
  • 比较
  • 关键字. 运算符. 比较
  • 关键字. 运算符. 比较. 相等性
  • 关键字. 运算符. 比较. 相等性. 键转换
  • 关键字. 运算符. 比较. 相等性. 严格
  • 关键字. 运算符. 比较. 非相等性
  • 关键字. 运算符. 比较. 非相等性. 键转换
  • 关键字. 运算符. 比较. 非相等性. 严格
  • 关键字. 运算符. 关系
  • 关键字. 运算符. 关系. 大于
  • 关键字. 运算符. 关系. 大于等于
  • 关键字. 运算符. 关系. 在内
  • 关键字. 运算符. 关系. 实例类型
  • 关键字. 运算符. 关系. 小于
  • 关键字. 运算符. 关系. 小于等于
  • 评估型
  • 关键字. 运算符. 访问器
  • 关键字. 运算符. 访问器. 装饰器
  • 关键字. 运算符. 访问器. 可选链
  • 关键字. 运算符. 逗号
  • 关键字. 运算符. 新建
  • 关键字. 运算符. 管道（智能与F#管道提议）
  • 关键字. 运算符. 扩展
  • 关键字. 运算符. 三元
  • 关键字. 运算符. 三元. 否则
  • 关键字. 运算符. 三元. 如果
  • 关键字. 运算符. 单一
  • 关键字. 运算符. 单一. 类型
  • 关键字. 运算符. 单一. 无效
  • 逻辑型
  • 关键字. 运算符. 逻辑
  • 关键字. 运算符. 逻辑. 与
  • 关键字. 运算符. 逻辑. 非
  • 关键字. 运算符. 逻辑. 或
  • 关键字. 运算符. 逻辑. 或. 空合并
  • 元. 类型转换. 布尔型（例如：`!!val`）
  • 数学
  • 关键字. 运算符. 算术
  • 关键字. 运算符. 算术. 加法
  • 关键字. 运算符. 算术. 减量
  • 关键字. 运算符. 算术. 减量. 后缀
  • 关键字. 运算符. 算术. 减量. 前缀
  • 关键字. 运算符. 算术. 除法
  • 关键字. 运算符. 算术. 指数
  • 关键字. 运算符. 算术. 数量递增
  • 关键字. 运算符. 算术. 数量递增. 后缀
  • 关键字. 运算符. 算术. 数量递增. 前缀
  • 关键字. 运算符. 算术. 取余
  • 关键字. 运算符. 算术. 乘法
  • 关键字. 运算符. 算术. 符号
  • 关键字. 运算符. 算术. 符号. 负号
  • 关键字. 运算符. 算术. 符号. 正号
  • 关键字. 运算符. 算术. 减法
• 语句
  • 通用
  • 实体. 名称. 语句（语句标签）
  • 关键字. 控制流. 跳出
  • 关键字. 控制流. 抛出异常
  • 标点符号. 定义. 块（任何块语句的大括号）
  • 标点符号. 分隔符. 语句标签（语句标签冒号）
  • 标点符号. 终止. 语句（终端分号或空语句）
  • 条件语句
  • 关键字. 控制. 条件
  • 关键字. 控制. 条件. 否则
  • 关键字. 控制. 条件. 如果
  • 关键字. 控制. 切换（切换关键字）
  • 关键字. 控制. 切换. 情况（情况关键字）
  • 关键字. 控制. 切换. 情况. 默认（ 默认关键字，在切换中）
  • 标点符号. 定义. 块. 条件（if 或 else 的大括号）
  • 标点符号. 定义. 块. 切换（switch 的大括号）
  • 标点符号. 定义. 表达式. 条件（if 的括号）
  • 标点符号. 定义. 表达式. 切换（switch 的括号）
  • case或default后面的冒号
  • 循环语句
  • keyword.control.flow.continue
  • keyword.control.flow.loop
  • keyword.control.loop.do
  • keyword.control.loop.each (已弃用)
  • keyword.control.loop.for
  • keyword.control.loop.in
  • keyword.control.loop.of
  • keyword.control.loop.while
  • punctuation.definition.block.loop (在while (x) {...}中的花括号)
  • punctuation.definition.expression.loop (在while (x) {...}中的括号)
  • punctuation separator.loop-expression (C样式的for语句中的分号)
  • try语句
  • keyword.control.trycatch
  • keyword.control.trycatch.catch
  • keyword.control.trycatch.finally
  • keyword.control.trycatch.try
  • (所有三个中的花括号)
  • (在catch (err)中的括号)
  • variable.parameter.catch (在catch (err)中的err)
  • 模块语句
  • entity.name.module.export
  • entity.name.module.import
  • punctuation.definition.assertions (在import x from 'z' assert { type: "json" }中的花括号)
  • punctuation.definition.module-binding (在import { x, y } from 'z'中的花括号)
  • (在assert { type: "json" }中的冒号)
  • (在assert { type: "json" }中的逗号)
  • (在import { x, y } from 'z'中的逗号)
  • storage.modifier.module.as
  • storage.modifier.module.assert
  • storage.modifier.module.default
  • storage.modifier.module.from
  • storage.modifier.module.namespace (在import * from z中的星号)
  • storage.type.module.export
  • storage.type.module.import
  • variable.annotation.assertion.key (在assert { type: "json" }中的键“type”)
  • variable.other.readwrite.export
  • variable.other.readwrite.import
  • 无意义
  • keyword.control.with (已弃用)
  • keyword.other.debugger (已弃用)
  • punctuation.definition.block.with (已弃用)
  • punctuation.definition.expression.with (已弃用)
• 变量与常量
  • 声明
  • storage.type.constant
  • storage.type.variable.let
  • storage.type.variable.var
  • 绑定模式（解构赋值）
  • entity.other.property-binding (在let { y: z } = x中的y)
  • punctuation.definition.binding
  • punctuation.definition.binding.array
  • punctuation.definition.binding.object
  • punctuation.separator.array-element.binding (数组绑定中的逗号)
  • punctuation.separator.binding-binding (这里的逗号：let x, y)
  • punctuation.separator.object-member.binding (对象模式中的逗号)
  • punctuation.separator.property-binding (在let { y: z } = x中的冒号)
  • 有关参数声明中绑定模式的函数
• 标识符
  • 通用
  • variable.other.readwrite
  • variable.other.readwrite.allCap
  • variable.other.readwrite.initCap
  • variable.other.readwrite.property
  • variable.other.readwrite.property.allCap
  • variable.other.readwrite.property.initCap
  • 上下文引用与哑引用
  • variable.language.arguments
  • variable.language.function-sent (提议的生成器初始next参数)
  • variable.language.import-dynamic
  • variable.language.import-meta
  • variable.language.new-target.fake-accessor (在new.target中的点)
  • variable.language.new-target.fake-object (在new.target中的new)
  • variable.language.new-target.fake-property (在new.target中的target)
  • variable.language.partial-application (局部应用提议)
  • variable.language.super
  • variable.language.this
  • variable.language.topic (智能管道提议)
  • 特殊属性
  • variable.other.readwrite.property.proto (例如x.__proto__；一份证书 sang坏部分)
  • variable.other.readwrite.property.prototype (例如X.prototype)
  • 本地（近乎本地）对象
  • support.class.builtin (例如Array)
  • support.function.builtin (例如parseInt)
  • support.variable.builtin (例如Math)
• JSX
  • entity.name.tag.jsx (HTML元素名称)
  • keyword.operator.accessor.jsx（在‘命名空间’元素名称中访问点）
  • keyword.operator.spread.jsx（属性插值中的展开运算符）
  • meta.interpolation.jsx（覆盖插值序列）
  • meta.namespace.jsx（组件成员表达式中前缀序列）
  • punctuation.definition.attribute.begin.jsx（单引号或双引号）
  • punctuation.definition.attribute.end.jsx
  • punctuation.definition.interpolation.begin.jsx（花括号）
  • punctuation.definition.interpolation.end.jsx
  • punctuation.definition.tag.begin.jsx（元素标记分隔符）
  • punctuation.definition.tag.end.jsx
  • punctuation.definition.tag.fragment.begin.jsx
  • punctuation.definition.tag.fragment.end.jsx
  • punctuation.separator.attribute-value.jsx（等号）
  • string.attribute.jsx（字面属性值）
  • string.text.jsx（字面字符数据）
  • variable.other.entity-reference.jsx（html/xml实体引用）
  • variable.other.attribute.jsx（属性名称）
• 样式化的JSX（来自Sublime的CSS语法）
  • comment.block.css
  • constant.numeric.css
  • entity.other.attribute-name.class.css
  • entity.other.attribute-name.id.css
  • entity.other.pseudo-class.css
  • entity.other.pseudo-element.css
  • keyword.control.at-rule.css
  • keyword.operator.attribute-selector.css
  • keyword.other.unit.css
  • meta.function-call.css
  • meta.property-name.css
  • meta.property-value.css（实际上包括许多其他项）
  • meta.styled-jsx.global.jsx
  • punctuation.definition.comment.css
  • punctuation.section.property-list.css
  • punctuation.separator.combinator.css（包括calc运算符等）
  • punctuation.separator.key-value.css
  • punctuation.terminator.rule.css
  • source.css
  • string.quoted.css
  • string.unquoted.css
  • support.type.custom-property.name.css
• 其他
  • 无效
  • invalid.deprecated（例如 with）
  • invalid.illegal.newline（例如，在单引号字符串内）
  • invalid.illegal.octal-escape（例如，'\\101'；自ES3起无效）
  • invalid.illegal.token（语法错误）
  • invalid.merge-conflict
  • invalid.merge-conflict.delimiter（例如，'<<<<<<< HEAD'）
  • meta.whitespace
  • punctuation.definition.expression（括号表达式的括号）
  • variable.other.readwrite.decorator（如果装饰器表达式以标识符开头，这是一种典型情况，则将应用此范围）

符号辅助作用域

这些范围用于促进符号列表的正确填充。

• meta.symbol-helper.arrow.es
• meta.symbol-helper.class.es
• meta.symbol-helper.function.es
• meta.symbol-helper.generator.es

互操作性作用域

这些范围与其他上述范围并存，以最大限度地提高与现有主题的互操作性，特别是针对JSNext和Babel Sublime的主题。

• constant.other.object.key.js
• entity.name.class.js
• entity.name.function.js
• entity.name.method.js
• entity.name.tag.js
• entity.name.type.new
• entity.quasi.element.js
• entity.quasi.tag.name.js
• keyword.generator.asterisk.js
• keyword.operator.module.js
• keyword.other.js
• meta.brace.curly.js
• meta.brace.round.js
• meta.brace.square.js
• meta.delimiter.comma.js
• meta.function-call
• meta.function.arrow.js
• meta.function.js
• meta.instance.constructor
• meta.separator.comma.js
• punctuation.definition.tag.js
• punctuation.quasi.element.begin.js
• punctuation.quasi.element.end.js
• storage.type.accessor.js
• storage.type.extends.js
• storage.type.function.js
• storage.type.js
• string.regexp.js
• string.unquoted.label.js
• variable.language.proto
• variable.language.prototype

嵌套语法作用域

这些范围用于具有语法指令的模板字符串的内容，并以它们的语法简称为后缀。

• meta.interpolation.syntax.css
• meta.interpolation.syntax.html
• meta.interpolation.syntax.js
• meta.interpolation.syntax.json
• meta.interpolation.syntax.dot
• meta.interpolation.syntax.glsl
• meta.interpolation.syntax.shell
• meta.interpolation.syntax.sql
• meta.interpolation.syntax.xml
• meta.interpolation.syntax.yaml

关于作用域惯例

我已经使用现有的tmLanguage约定，以及JSNext和Babel Sublime作为范围命名的指南。尽管如此，仍有相当多的差异。其中一些是先前合并的元素进行歧义度消除的结果。

在少数情况下，原始的Sublime JS tmLanguage存在错误，Babel和JSNext保留了它们。我选择冒着与现有主题兼容性降低的风险来修正这些错误。例如，'with'不是一个运算符。但这类错误不多，而且通常是影响不大的小事，不会影响大多数主题。

有时，我选择使用现有的tmLanguage约定而不是特定域的选择。例如，Babel使用quasi，但许多tmLanguages和主题已经定位到string.interpolated。在这种情况下，我通常会为标记“双重范围”以便可以任意定位。

其他差异源自定义的目的，可能略有不同。我希望范围能够非常反映出语言的语法。例如，entity.name.function将出现在函数声明中，但不会出现在函数调用中；在Ecmascript Sublime中，在这个上下文中你所看到的是一个标识符（具有范围）和一个调用（也具有范围），而不是实体名称。

许多新的范围涉及标点符号。punctuation.definition范围命名空间是这种东西的现有约定。所以对于if语句，例如，你可以使用以下内容

• 关键字. 控制. 条件. 否则
• 关键字. 控制. 条件. 如果
• 标点符号定义块条件开始
• 标点符号定义块条件结束
• 标点符号定义表达式条件开始
• 标点符号定义表达式条件结束

可能没有人需要包括'begin'或'end'，但这种类型的尾随特定性有时有助于调试，而且无论如何，这是一种现有约定。范围是层次选择器，因此如果想要整个语句使用相同的颜色，那么在YAML-tmTheme中的定义可以如下所示

- name: If / else statements
  scope: >-
    keyword.control.conditional,
    punctuation.definition.block.conditional,
    punctuation.definition.expression.conditional
  settings:
    foreground: '#FF0000'

如果你对主题制作还不太熟悉，确保从Package Control中获取AAAPackageDev和ScopeAlways。前者将允许你将可读性高的YAML翻译成tmTheme XML，后者将在状态栏中显示光标位置正在应用哪些范围。

更多关于作用域定义本身的信息

为什么它如此庞大？

如果你在里面探索，可能会认为有这么多冗余组件是疯狂的事情。在许多情况下，使用更深背景栈上的meta_scopes可以达到类似的结果。

简单来说，这样的非常非DRY方法是通过很多实验得出的。Sublime语法功能强大，但可能尝试做一些预期之外的事情。采用非常“语法”的方法（实际上是根据ES6最终草案进行的）让我们能够拥有所有新和解耦的范围来使用，但句法精确性的代价是需要在面对无效标记时尽可能优雅地失败。

我找到了几种防止或缓解“无效输入级联”的技术，其中最重要的是在任何给定时间保持上下文栈尽可能浅 - 也就是说，偏好线性而不是垂直的上下文转换。这正是需要重复的原因。

然而，当然有一些地方我们可以合并，特别是通过创建仅作为构建其他实际访问的上下文的包含器的三级上下文。

如果将来可以像设置多个上下文一样弹出多个上下文，我们可能可以大大减少定义的复杂性和重复性。

防止级联效应的另一种主要技术是明确处理一些非法情况。实际上，有相当多的这种“手工”纠正。由于我们知道某些东西可能会是某人正在输入的临时有效输入，我们可以标记单个无效标记为无效，但然后仍然转换为我们相当确信的下一个标记。随着时间的推移，我计划添加更多类似的东西，但只有在使用中发现了合适的位置。

几乎与表达式相关的所有内容为什么都出现了两次？

我决心把“in”（运算符）与“in”（控制词）区分开来。据我所知，这是唯一能够实现这个目标的方式。这个想法实际上也存在于形式语法定义中；这并不是我自己凭空想出来的。

一个复杂的上下文转换网络会降低高亮效率吗？

出乎意料地，并没有。好吧，我并没有注意到问题。我不了解Sublime Text的内部工作原理，但如果你这么想的话，如果正则表达式匹配是成本最高的部分，那么Sublime的原子语法可能是高效的：每个上下文将只会尝试匹配那里实际预期出现的内容。

如何破坏它？

奇怪的分号换行符！实际上，它可以比tmLanguage中更有可能正确处理奇怪的换行符情况，因为在线性的语法序列中，如定义大多数语句的序列，上下文堆栈就是我们需要获得100%完美匹配的所有内容。但在ES表达式中——甚至比我想的还要多——存在一些情况，其中直到考虑允许放在下一行（我们无法查看的地方）的后续标记之前，标记是模糊不清的。

幸运的是，除了一个之外，所有这些换行符虽然合法，但完全愚蠢。也就是说，如果一个人真的写了这样的代码

label
: {
  [ a,
  b=4 ]
  = [ (c)
  => { c * 2, d } ]
}

……他们不应该有语法高亮显示。所以把这当做一个特性。

然而，即使在这些情况下，Ecmascript Sublime也会尝试恢复到一个高尚的努力。在上面的例子中。绑定模式应该是一个数组，但当它达到=4时，它会纠正剩余的部分。(c)将是一个表达式，但在箭头处它会确定它的真正位置等等。但不是一切都可以挽回：label将是一个标识符，但冒号看起来是无效的，因为在这个时候我们必须假设我们处于期望该序列解析为表达式的上下文中。

这些是一些技术上合法但令人讨厌的换行符可能导致不匹配的情况，其中竖线代表一个有问题的换行符

• 在一个for循环中区分“in”和“in”取决于对可能跨行的序列的向前看。
• 语句标签 | :
• 参数（s） | =>
• function | *
• async | function（但只在表达式中——这是因为在Node流行库中，async也可能会是一个标识符，适应这一点很重要）
• 标识符 | (（标识符不会被识别为调用）
• 标识符 | “（标识符不会被识别为标签）
• 还有其他各种类似的情况，主要关注的是“secondary”范围，如调用而不是核心范围。

还有一个让我感到不顺的地方

• 绑定模式 | 赋值运算符

与其他不同，这可能在理智些的人写的代码中出现。然而，在实践中，这种情况可能仍然非常罕见。