assets static move

assets/bpmn-js-properties-panel/CHANGELOG.md

@@ -0,0 +1,453 @@
+# Changelog
+
+All notable changes to [bpmn-js-properties-panel](https://github.com/bpmn-io/bpmn-js-properties-panel) are documented here. We use [semantic versioning](http://semver.org/) for releases.
+
+## Unreleased
+
+___Note:__ Yet to be released changes appear here._
+
+# 1.4.0
+
+* `FEAT`: use FEEL editor for FEEL expressions ([#706](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/706))
+* `FIX`: support jQuery as parent node ([#729](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/729))
+* `DEPS`: update to `@bpmn-io/properties-panel@0.18.0`
+* `DEPS`: update to `@bpmn-io/extract-process-variables@0.5.0`
+
+# 1.3.0
+
+* `FEAT`: set errors through context ([#160](https://github.com/bpmn-io/properties-panel/pull/160))
+* `DEPS`: update to `@bpmn-io/properties-panel@0.16.0`
+* `DEPS`: update to `bpmn-js@9.3.0`
+
+## 1.2.0
+
+* `FEAT`: enable multi-select state ([#687](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/678))
+* `FEAT`: display timestamp for template versions ([#698](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/698))
+* `FIX`: called decision decision ID made explicit ([#681](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/681))
+* `FIX`: focus value on create for form field of type enum ([#683](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/683))
+* `FIX`: add separator to process variable sources ([#714](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/714))
+* `FIX`: fix error when field injection for execution listener is created ([#710](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/710)
+* `CHORE`: fix audit errors ([#691](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/691))
+* `CHORE`: use codecov Github action ([#699](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/699))
+* `DEPS`: update to `bpmn-js@9.2.2`
+* `DEPS`: update to `diagram-js@8.6.0`
+* `DEPS`: update to `element-templates-validator@0.9.0`
+
+## 1.1.1
+
+### Element Templates
+
+* `FIX`: keep existing configuration after apply ([#661](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/661))
+* `FIX`: always override `hidden` configuration on apply ([#661](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/661))
+* `FIX`: do not render non-existing values ([#676](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/676))
+* `FIX`: pick-up correct template icon ([#670](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/670))
+
+## 1.1.0
+
+* `deps`: add `camunda-bpmn-js-behaviors` dependency ([#671](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/671))
+
+## 1.0.0
+
+_A complete rewrite of the library, based on modern foundations._
+
+* `FEAT`: rewrite project to new, [@bpmn-io/properties-panel](https://github.com/bpmn-io/properties-panel)-based architecture
+* `FEAT`: replace tabs with flat structure where groups are basic building blocks
+* `FEAT`: add "dirty" markers to notify non-default value of entry/entries in group
+* `FEAT`: keep open/closed state of the groups between elements
+* `FIX`: keep element name after template removal ([#570](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/570))
+* `CHORE`: add description for decision ID ([`5c8f9f2`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/5c8f9f2f3dea085371b5fee3c7b29c8c4d34192c))
+
+For more changes, read the alpha releases entries below.
+
+### Breaking changes
+
+* `PropertiesProvider#getTabs` is no longer used. Migrate to the new `PropertiesProvider#getGroups` API instead.
+  Check out [the example migration](https://github.com/bpmn-io/bpmn-js-examples/pull/142) and [this pull request](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/590) for guidance.
+* Previously exported entry factory functions are no longer available. Use components exported from
+  [`@bpmn-io/properties-panel`](https://github.com/bpmn-io/properties-panel) instead.
+* Element templates select has been removed. Handle [`elementTemplates.select` event](https://github.com/bpmn-io/bpmn-js-properties-panel/blob/v1.0.0-alpha.0/src/provider/element-templates/components/ElementTemplatesGroup.js#L132) or use [the element template chooser](https://github.com/bpmn-io/element-template-chooser) to implement template selection.
+
+## 1.0.0-alpha.13
+
+* `DEPS`: update to `@bpmn-io/properties-panel@0.13.2` ([#660](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/660))
+* `FIX`: only keep defined mappings (cloud-templates) ([#659](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/659))
+* `FEAT`: rearrange process props by relevance ([#656](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/656))
+
+## 1.0.0-alpha.12
+
+* `FIX`: move `modelerTemplateIcon` to property ([#658](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/658))
+
+## 1.0.0-alpha.11
+
+* `FEAT`: apply element template icons ([#641](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/641))
+* `FEAT`: change task type when element template is applied ([#648](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/648))
+* `FEAT`: display element template icons in header ([#650](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/650))
+* `FEAT`: add show callbacks to show error code and message name errors ([#654](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/654))
+* `FIX`: add `Variable name` entry to `Condition` group ([#651](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/651))
+
+## 1.0.0-alpha.10
+
+* `FIX`: do not use `inherits` ([#645](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/645))
+* `FIX`: use `browser` field of dependencies before falling back to `module` and `main` ([#646](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/646))
+
+## 1.0.0-alpha.9
+
+* `FEAT`: add show callbacks to show entries and errors ([#601](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/601))
+* `FEAT`: open element template custom groups ([#621](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/621))
+* `FEAT`: display template name in header ([#627](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/627))
+* `FEAT`: add documentation ref to header ([#629](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/629))
+* `FIX`: copy versioned element template ([#632](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/632))
+* `FIX`: use correct business object ([#634](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/634))
+* `FIX`: mark called decision ID as optionally FEEL ([#643](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/643))
+* `DEPS`: update to `@bpmn-io/extract-process-variables@v0.4.5`
+* `DEPS`: update to `@bpmn-io/properties-panel@0.13.1`
+
+## 1.0.0-alpha.8
+
+* `FIX`: correct display of messages ([#623](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/623))
+
+## 1.0.0-alpha.7
+
+* `FEAT`: add `ElementTemplates#applyTemplate` API ([#624](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/624))
+* `FEAT`: provide UMD distribution
+* `DEPS`: replace `semver` with `semver-compare` ([#622](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/622))
+
+## 1.0.0-alpha.6
+
+* `FEAT`: add `elementTemplates.createElement` API for `cloud-element-templates` ([#582](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/582))
+* `FEAT`: allow setting custom form key ([#592](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/592))
+* `FEAT`: reorder select options for implementation properties ([#597](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/597))
+* `FEAT`: mark FEEL expressions on input fields ([#599](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/599))
+* `FEAT`: add FEEL guidance on element templates ([#606](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/606))
+* `FEAT`: add references for `formType`, `throwEvent`, `user` and `multiInstance` ([#612](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/612))
+* `FIX`: set DMN implementation default to `<none>` ([#578](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/578))
+* `DEPS`: update to `bpmn-js@9.0.3`
+
+## 1.0.0-alpha.5
+
+* `FEAT`: validate cloud element templates against JSON Schema ([#561](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/561))
+* `FEAT`: use components instead of elements for all entries ([#590](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/590))
+* `FIX`: set correct title to element templates select ([#591](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/591))
+* `DEPS`: update to `@bpmn-io/properties-panel@0.11.0`
+* `DEPS`: update to `@bpmn-io/element-templates-validator@0.5.0`
+
+### Breaking Changes
+
+* `component` property of an entry must be an actual component, not an element.
+Checkout this [pull request](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/590) as a guidance.
+
+## 1.0.0-alpha.4
+
+* `FIX`: ensure compatibility with bpmn-js@8 ([#581](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/581))
+* `FIX`: reference missing adhoc subprocess icons ([#583](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/583))
+
+## 1.0.0-alpha.3
+
+* `FEAT`: add ability to create optional inputs & outputs ([#559](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/559))
+* `FEAT`: support drilldown ([#567](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/567))
+* `FEAT`: add templates property groups ([#563](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/563), [#564](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/564))
+* `FEAT`: add element templates support ([#540](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/540))
+* `FIX`: remove name property on associations ([#566](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/566), [#579](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/566))
+* `DEPS`: update to `zeebe-bpmn-moddle@0.11.0`
+* `DEPS`: update to `bpmn-js@9.0.0-alpha.2`
+
+## 1.0.0-alpha.1
+
+* `FEAT`: expose ZeebeDescriptionProvider ([c4b565](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/c4b565df6f861205f6df63a3e265375e0b10d4e7))
+* `FEAT`: re-enable `zeebe:calledDecision` ([dc32ec](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/dc32ecfed99cf1680bd7ff2ba126b664e6044040))
+* `FEAT`: support completion-condition for multi-instance ([324128](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/32412883e37c773b0d32329ec6e0ce8c87e0c2eb))
+* `FIX`: don't render empty element template descriptions ([656f80](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/656f801c22d2c0d30df0b1c1ef4f80ebbf3b880d))
+* `FIX`: allow rendering of HTML descriptions ([#547](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/547) and [#375](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/375))
+* `FIX`: update instead of destroy new root element ([b5a29d](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/b5a29d41d5493d3a35be9b19a961257d46def4af))
+* `FIX`: reorder unlink / remove actions in dropdown ([#498](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/498))
+* `DEPS`: bump to `bpmn-js@8.9.1`
+
+## 1.0.0-alpha.0
+
+* `FEAT`: rewrite project to new, [@bpmn-io/properties-panel](https://github.com/bpmn-io/properties-panel)-based architecture
+* `FEAT`: replace tabs with flat structure where groups are basic building blocks
+* `FEAT`: add "dirty" markers to notify non-default value of entry/entries in group
+* `FEAT`: keep open/closed state of the groups between elements
+
+### Breaking Changes
+
+* `PropertiesProvider#getTabs` is no longer used. Migrate to the new `PropertiesProvider#getGroups` API instead.
+  Check out [the example migration](https://github.com/bpmn-io/bpmn-js-examples/pull/142) for guidance.
+* Previously exported entry factory functions are no longer available. Use components exported from
+  [`@bpmn-io/properties-panel`](https://github.com/bpmn-io/properties-panel) instead.
+* Element templates select has been removed. Handle [`elementTemplates.select` event](https://github.com/bpmn-io/bpmn-js-properties-panel/blob/v1.0.0-alpha.0/src/provider/element-templates/components/ElementTemplatesGroup.js#L132) to implement template selection.
+
+## 0.46.0
+
+* `FEAT`: graceful handle incompatible properties providers ([#482](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/482))
+* `FIX`: don't use browser defaults for undo/redo ([#483](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/483))
+* `DEPS`: bump to `diagram-js@7.5.0`
+* `DEPS`: bump to `bpmn-js@8.8.1`
+
+## 0.45.0
+
+* `FEAT`: allow configuring camunda forms ([#480](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/480))
+* `DEPS`: update to camunda-bpmn-moddle@6.1.0
+
+## 0.44.1
+
+* `DEPS`: update to `diagram-js@7.4.0` ([#479](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/479))
+
+## 0.44.0
+
+* `FEAT`: allow independent configuration of variables and local in `camunda:in|out` element template bindings ([`5e5b2d6f`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/5e5b2d6f7a45fda4d46909ba21a52a66c12d6451))
+* `DEPS`: update to `element-templates-validator@0.2.0`
+* `DEPS`: update to `bpmn-js@8.7.1`
+
+## 0.43.1
+
+* `FIX`: preserve Windows newline character ([#471](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/471))
+* `DEPS`: update to `bpmn-js@8.7.0` and `bpmn-moddle@7.1.1`
+
+## 0.43.0
+
+* `FEAT`: update existing documentation entries ([#465](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/465))
+* `FIX`: open and close properties when working as web component ([#458](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/458))
+* `FIX`: give properties table inputs a unique identifier ([#407](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/407))
+* `DEPS`: bump to `bpmn-js@8.5.0` and `diagram-js@7.3.0`
+
+## 0.42.0
+
+* `FEAT`: support templating of `camunda:ErrorEventDefinition` and global `bpmn:Error` elements ([#424](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/424), [#425](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/425), [#441](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/441))
+* `FEAT`: validate element templates via JSON Schema ([#455](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/455))
+* `FIX`: ensure necessary part of variable title is always displayed ([`452f4488`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/452f4488d2a65db858f6e67f4684e8c413af0ad5))
+* `FIX`: use pre-compiled element templates validator ([#462](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/462))
+* `CHORE`: make extension elements helper always return an array ([#447](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/447))
+* `CHORE`: bump to `bpmn-js@8.3.0`
+
+### Breaking Changes
+
+* `ExtensionElementsHelper#getExtensionElements` now returns an empty array if no extension element of the requested type was found, instead of returning `undefined`.  This means the return value is now always _truthy_.
+
+## 0.41.0
+
+* `FEAT`: support multiple properties panel providers ([#438](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/438))
+* `FEAT`: validate element template schema version provided as part `$schema` attribute and ignore unsupported versions ([#2083](https://github.com/camunda/camunda-modeler/issues/2083))
+* `FEAT`: provided clearer labels for `bpmn:*EventDefinitions` ([#421](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/421))
+* `FEAT`: support error event definitions for external service tasks ([#422](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/422))
+* `FEAT`: support new element templates scope descriptors ([#423](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/423))
+* `FIX`: don't render `version` in element template view, when applied element template has no `version` ([#2101](https://github.com/camunda/camunda-modeler/issues/2101))
+* `FIX`: always provide `id` and `name` of an element template when logging an error ([#2111](https://github.com/camunda/camunda-modeler/issues/2111))
+* `CHORE`: bump to `@bpmn-io/extract-process-variables@0.4.1`
+* `CHORE`: bump to `bpmn-js@8.2.1`
+
+## 0.40.0
+
+* `CHORE`: bump to `@bpmn-io/extract-process-variables@0.4.0`
+* `CHORE`: bump to `bpmn-js@8.2.0`
+* `CHORE`: bump to `bpmn-moddle@7.0.4`
+
+## 0.39.0
+
+* `FEAT`: add 'Participant' prefix to properties panel participant inputs for clarity ([#413](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/413))
+* `CHORE`: bump to `bpmn-js@8.1.0`
+* `CHORE`: bump to `diagram-js@7.0.0`
+
+### Breaking Changes
+
+* Participant input `data-entry` html attribute was changed from `id` to `participant-id`
+
+## 0.38.1
+
+* `FIX`: fix displayed template version ([#408](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/408), [#409](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/409))
+
+## 0.38.0
+
+* `FEAT`: allow updating templates ([#399](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/399))
+* `FEAT`: recognize template versions ([#398](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/398))
+* `FEAT`: prevent changing template before the current one is unlinked or removed ([#398](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/398))
+* `FIX`: stop using variable name as id ([#405](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/405))
+* `CHORE`: update `camunda-bpmn-moddle` to v4.5.0 ([`f8ed2081`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/f8ed2081538b0d604ad7fc1a5949ab00ec0c109a))
+
+### Breaking Changes
+
+* Element template select is no longer visible when an element template is applied. Unlink or remove the template to be able to apply another one ([#398](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/398)).
+* `getDefaultTemplate` helper has been removed. Use `ElementTemplates#getDefault` instead ([#398](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/398)).
+
+## 0.37.6
+
+* `FIX`: escape element template not found description ([#397](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/397))
+* `FIX`: correctly use an idPrefix to determine scriptType of i/o parameter in all cases ([`aa287d54`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/aa287d54e1626190b942030d6f256e938875bfe0))
+* `CHORE`: remove `bpmn-font` dependency
+
+## 0.37.5
+
+* `FIX`: unlink template on replace
+* `FIX`: correct removal of event template
+
+## 0.37.4
+
+* `FIX`: correctly write `camunda:variableEvents` event ([#355](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/355))
+
+## 0.37.3
+
+* `FIX`: re-enable `entriesVisible` ([#389](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/389))
+
+## 0.37.2
+
+* `FIX`: render validation error below checkbox labels ([#359](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/359))
+
+## 0.37.1
+
+* `FIX`: ensure undo and redo is working for template parameters ([#380](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/380))
+
+## 0.37.0
+
+* `FEAT`: add toggle switch entry factory ([`51dd639c`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/51dd639c3f278f3c0cb2d089bd3ac305d61e4e7c))
+* `FEAT`: add template parameter toggle ([#365](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/365))
+* `FEAT`: crop descriptions ([#369](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/369))
+* `FIX`: prevent hiding group headers ([#373](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/373))
+* `CHORE`: update process variables overview description ([`f32e424b`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/f32e424b5aea4ab2dd77f525c555c2959b4207da))
+* `CHORE`: bump to `diagram-js@6.7.1`
+
+### Breaking Changes
+
+* all factories now return DOM instead of string ([#370](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/370))
+* API of all factories has changed and now requires `translate` as first parameter ([#370](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/370))
+
+## 0.36.0
+
+* `FEAT`: add new input and output parameter editing as default to _Tempate_ tab ([#363](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/363))
+* `FEAT`: add `Template` tab ([#364](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/364))
+* `FEAT`: add new input and output parameter editing to _Input/Output_ tab
+* `FEAT`: add auto suggest for editing input and output parameters ([#357](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/357))
+* `FEAT`: add _Variables_ tab ([#347](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/347))
+* `CHORE`: bump to `bpmn-js@7.3.0`
+
+### Breaking Changes
+
+* change parameters of `CamundaPropertiesProvider` ([#364](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/364))
+* remove `entriesVisible` property to disallow chaning visibility of entries outside of element templates tab ([#364](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/364))
+* `button` elements will not be styled by default anymore, instead, they will be styled using the `action-button` class ([#364](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/364))
+* `propertiesPanel.isEntryVisible` event fired with `element`, `entry`, `group` and `tab` ([#364](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/364))
+* PropertiesActivator#isEntryVisible called with `element`, `entry`, `group` and `tab` (e.g. `propertiesActivator.isEntryVisible(element, entry, group, tab)`) ([#364](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/364))
+* `propertiesPanel.isPropertyEditable` event fired with `element`, `entry`, `group` and `tab` ([#364](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/364))
+* PropertiesActivator#isEntryEditable called with `element`, `entry`, `group`, `propertyName` and `tab` (e.g. `propertiesActivator.isEntryEditable(propertyName, element, entry, group, tab)`) ([#364](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/364))
+
+## 0.35.0
+
+* `FEAT`: align colors with Camunda Modeler ([`10892b18e`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/10892b18efef14a426ddcd6d3ec4e4a254171afa))
+
+## 0.34.0
+
+* `CHORE`: add promise polyfill for phantom-js ([`e9d5969f`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/e9d5969f141e1424a3026fc32f2a380e40507118))
+* `FEAT`: add variable name hint for form field ids ([`f0d04332`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/f0d0433291e9049062aee17b67a179bb3bcdfeb5))
+* `FEAT`: add tooltip support for dropdown options ([`2aa74ee8`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/2aa74ee82781260844e27e5f7fffbba6cb02ad5d))
+* `CHORE`: bump to `bpmn-js@7.2.0`
+* `CHORE`: update bpmn-js peer dependency range with `^7x`
+
+## 0.33.2
+
+* `FIX`: paste always as plain text ([#265](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/265))
+
+## 0.33.1
+
+* `FIX`: deprecate placeholders ([`257d0c1f`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/257d0c1f528cf68a08e214f10ec82925314be48e))
+
+## 0.33.0
+
+* `FEAT`: support `update` events for task listeners ([`775fae0d`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/775fae0d41cfaf518948b7a5ab8806af034ba1e0))
+* `FEAT`: support `timeout` events for task listeners ([`eb3bcde7`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/eb3bcde72c8cc2afed3515a4ef9ab5302067b9e5))
+* `CHORE`: update `bpmn-js` peer dependency range with `^5.x || ^6.x`
+
+## 0.32.2
+
+* `FIX`: support line breaks in Entry Field Description ([#319](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/319))
+
+## 0.32.1
+
+* `FIX`: don't allow editing of `camunda:InputOutput` on gateways ([#314](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/314))
+
+## 0.32.0
+
+* `FEAT`: support `camunda:errorMessage` ([#313](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/313))
+* `CHORE`: move camunda related error properties to correct provider ([`957beb`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/957bebf77b5307a9539f67d15aae3996dd63c080))
+
+## 0.31.0
+
+* `FEAT`: sanitize entities when building HTML ([#296](https://github.com/bpmn-io/bpmn-js-properties-panel/issues/296))
+* `FEAT`: support name editing for `bpmn:Group`
+* `FEAT`: improve text annotation label
+* `FEAT`: translate error messages
+* `FIX`: remove accidential whitespace ([`180ba5b9`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/180ba5b9e88adb1d9d1b9bfbd10536fcb2d62709))
+* `CHORE`: update `bpmn-js` peer dependency range to `^3.x || ^4.x`
+
+## 0.30.0
+
+* `FEAT`: improve localization ([#295](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/295))
+* `FEAT`: add hint about task definition key in user task ([#294](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/294))
+
+## 0.29.0
+
+* `FEAT`: add hints to returned Java types ([#286](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/286))
+* `FEAT`: show target variable name instead of index ([#287](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/287))
+
+## 0.28.2
+
+* `CHORE`: update to `npm-run-all@4.1.5`
+
+## 0.28.1
+
+* `FIX`: handle correct `camunda:isStartableInTasklist` default value
+
+## 0.28.0
+
+* `FEAT`: support `camunda:isStartableInTasklist` ([#284](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/284))
+* `FIX`: don't restrict properties panel height unnecessarily ([#283](https://github.com/bpmn-io/bpmn-js-properties-panel/pull/283))
+
+## 0.27.0
+
+* `CHORE`: `bpmn-js@3` compatibility
+
+## 0.26.0
+
+* `FEAT`: provide pre-built styles
+* `CHORE`: bump dependency versions
+* `CHORE`: migrate to `lodash@4`
+
+## 0.25.2
+
+* `FIX`: correct variable mapping not removing target props
+
+## 0.25.1
+
+* `FIX`: handle delete key strokes in `selects`
+
+## 0.25.0
+
+* `CHORE`: revert [`6c757170`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/6c757170d76996da311c758c5923a530d86ba7f3), as it disabled certain [usage scenarios](https://github.com/camunda/camunda-modeler/issues/792)
+
+## 0.24.1
+
+* `FIX`: show description for select entries
+
+## 0.24.0
+
+* `FEAT`: binding of business rule tasks and call activities can be set to version tag [`10738e92`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/10738e927fdb297fc9042e8103fb4fde60ae7264)
+
+* `FEAT`: validate source and target of of variables [`dd163e66`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/dd163e6674454288cb48aa5592fac608544b8cb6)
+
+* `FEAT`: selecting label of an element will show all element properties in properties panel [`40935240`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/40935240b4ef01bfd435f7c20d594cbea1976832)
+
+* `FEAT`: condition of conditional events can be set to script [`c38f90bd`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/c38f90bd5a77490f20bba52884f97e26a55f4f31)
+
+* `FIX`: form data is removed when empty [`481b5c1f`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/481b5c1f6b1fac2e23e204050ca0ec097d4914eb)
+
+* `FEAT`: business key expression of camunda ins can be edited [`3f1d780f`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/3f1d780fc84d3f69a3528c3b800fa4b16d7ce95e)
+
+* `FIX`: timer definition type of intermediate catching events can't be set to cycle [`6c757170`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/6c757170d76996da311c758c5923a530d86ba7f3)
+
+* `FEAT`: candidate starter users and groups of processes can be edited [`c1d51285`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/c1d512854f070c0af345f730fa005acdfa539635)
+
+* `FEAT`: variables of signal events can be edited [`aba8287e`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/aba8287ea5645d0c7db974422e68be6b852257a4)
+
+* `FEAT`: condition and variable name of conditional start events can be edited [`9cc1d6c5`](https://github.com/bpmn-io/bpmn-js-properties-panel/commit/9cc1d6c5ef6a9cd45b292ed7749b7bfc967bc145)
+
+## ...
+
+Check `git log` for earlier history.

assets/bpmn-js-properties-panel/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 camunda Services GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

assets/bpmn-js-properties-panel/README.md

@@ -0,0 +1,201 @@
+> Extending the properties panel changed significantly with `bpmn-js-properties-panel>=1`. For the `0.x` version of the library, check out [the 0.x branch](https://github.com/bpmn-io/bpmn-js-properties-panel/tree/0.x). Read more on the changes [in the changelog](https://github.com/bpmn-io/bpmn-js-properties-panel/blob/master/CHANGELOG.md#100-alpha0).
+
+# bpmn-js-properties-panel
+
+[![CI](https://github.com/bpmn-io/bpmn-js-properties-panel/workflows/CI/badge.svg)](https://github.com/bpmn-io/bpmn-js-properties-panel/actions?query=workflow%3ACI)
+
+A properties panel extension for [bpmn-js](https://github.com/bpmn-io/bpmn-js) that adds the ability to edit technical properties (generic and [Camunda](https://camunda.com)).
+
+[![bpmn-js-properties-panel screenshot](./docs/screenshot.png "Screenshot of the bpmn-js modeler with properties panel")](https://github.com/bpmn-io/bpmn-js-examples/tree/master/properties-panel)
+
+
+## Features
+
+The properties panel allows users to edit invisible BPMN properties in a convenient way.
+
+Some of the features are:
+
+* Edit element ids, multi-instance details and more
+* Edit execution related [Camunda](http://camunda.org) properties
+* Redo and undo (plugs into the [bpmn-js](https://github.com/bpmn-io/bpmn-js) editing cycle)
+
+
+## Usage
+
+Provide two HTML elements, one for the properties panel and one for the BPMN diagram:
+
+```html
+<div class="modeler">
+  <div id="canvas"></div>
+  <div id="properties"></div>
+</div>
+```
+
+Bootstrap [bpmn-js](https://github.com/bpmn-io/bpmn-js) with the properties panel and a [properties provider](https://github.com/bpmn-io/bpmn-js-properties-panel/tree/master/src/provider):
+
+
+```javascript
+import BpmnModeler from 'bpmn-js/lib/Modeler';
+import {
+  BpmnPropertiesPanelModule,
+  BpmnPropertiesProviderModule,
+} from 'bpmn-js-properties-panel';
+
+const modeler = new BpmnModeler({
+  container: '#canvas',
+  propertiesPanel: {
+    parent: '#properties'
+  },
+  additionalModules: [
+    BpmnPropertiesPanelModule,
+    BpmnPropertiesProviderModule
+  ]
+});
+```
+
+### Styling
+
+For proper styling include the necessary stylesheets:
+
+```html
+<link rel="stylesheet" href="https://unpkg.com/bpmn-js-properties-panel/dist/assets/properties-panel.css">
+```
+
+If you use the `ElementTemplatesProviderModule`, include also its stylesheet:
+
+```html
+<link rel="stylesheet" href="https://unpkg.com/bpmn-js-properties-panel/dist/assets/element-templates.css">
+```
+
+
+### Dynamic Attach/Detach
+
+You may attach or detach the properties panel dynamically to any element on the page, too:
+
+```javascript
+const propertiesPanel = bpmnJS.get('propertiesPanel');
+
+// detach the panel
+propertiesPanel.detach();
+
+// attach it to some other element
+propertiesPanel.attachTo('#other-properties');
+```
+
+
+### Use with Camunda properties
+
+In order to be able to edit [Camunda](https://camunda.com) related properties, use the [camunda platform properties provider](https://github.com/bpmn-io/bpmn-js-properties-panel/tree/master/src/provider/camunda-platform).
+In addition, you need to define the `camunda` namespace via [camunda-bpmn-moddle](https://github.com/camunda/camunda-bpmn-moddle).
+
+```javascript
+import BpmnModeler from 'bpmn-js/lib/Modeler';
+import {
+  BpmnPropertiesPanelModule,
+  BpmnPropertiesProviderModule,
+  
+  // use Camunda Platform properties provider
+  CamundaPlatformPropertiesProviderModule
+} from 'bpmn-js-properties-panel';
+
+// use Camunda BPMN Moddle extension
+import CamundaExtensionModule from 'camunda-bpmn-moddle/lib';
+
+// use Camunda BPMN namespace
+import camundaModdleDescriptors from 'camunda-bpmn-moddle/resources/camunda';
+
+const modeler = new BpmnModeler({
+  container: '#canvas',
+  propertiesPanel: {
+    parent: '#properties'
+  },
+  additionalModules: [
+    BpmnPropertiesPanelModule,
+    BpmnPropertiesProviderModule,
+    CamundaPlatformPropertiesProviderModule,
+    CamundaExtensionModule
+  ],
+  moddleExtensions: {
+    camunda: camundaModdleDescriptors
+  }
+});
+...
+```
+
+### API
+
+#### `BpmnPropertiesPanelRenderer#attachTo(container: HTMLElement) => void`
+
+Attach the properties panel to a parent node.
+
+```javascript
+const propertiesPanel = modeler.get('propertiesPanel');
+
+propertiesPanel.attachTo('#other-properties');
+```
+
+#### `BpmnPropertiesPanelRenderer#detach() => void`
+
+Detach the properties panel from its parent node.
+
+```javascript
+const propertiesPanel = modeler.get('propertiesPanel');
+
+propertiesPanel.detach();
+```
+
+#### `BpmnPropertiesPanelRenderer#registerProvider(priority: Number, provider: PropertiesProvider) => void`
+
+Register a new properties provider to the properties panel.
+
+```javascript
+class ExamplePropertiesProvider {
+  constructor(propertiesPanel) {
+    propertiesPanel.registerProvider(500, this);
+  }
+
+  getGroups(element) {
+    return (groups) => {
+
+      // add, modify or remove groups
+      // ...
+
+      return groups;
+    };
+  }
+}
+
+ExamplePropertiesProvider.$inject = [ 'propertiesPanel' ];
+```
+
+## Additional Resources
+
+* [Issue tracker](https://github.com/bpmn-io/bpmn-js-properties-panel)
+* [Forum](https://forum.bpmn.io)
+* [Example Project](https://github.com/bpmn-io/bpmn-js-examples/tree/master/properties-panel)
+
+
+## Development
+
+Prepare the project by installing all dependencies:
+
+```sh
+npm install
+```
+
+Then, depending on your use-case, you may run any of the following commands:
+
+```sh
+# build the library and run all tests
+npm run all
+
+# spin up a single local modeler instance
+npm start
+
+# run the full development setup
+npm run dev
+```
+
+## License
+
+MIT

assets/bpmn-js-properties-panel/dist/assets/element-templates.css

@@ -0,0 +1,83 @@
+.bio-properties-panel {
+  --select-template-background-color: var(--color-blue-205-100-50);
+  --select-template-hover-background-color: var(--color-blue-205-100-45);
+  --select-template-fill-color: var(--color-white);
+  --select-template-label-color: var(--color-white);
+
+  --unknown-template-background-color: var(--color-red-360-100-45);
+  --unknown-template-hover-background-color: var(--color-red-360-100-40);
+
+  --select-template-information-text-color: var(--color-grey-225-10-55);
+}
+
+.bio-properties-panel-header-template-icon {
+  object-fit: contain;
+}
+
+.bio-properties-panel-templates-group .bio-properties-panel-group-header {
+  position: initial;
+}
+
+.bio-properties-panel-templates-group .bio-properties-panel-group-header-button:not(.bio-properties-panel-arrow) {
+  padding-right: 6px;
+  padding-left: 9px;
+  border-radius: 11px;
+}
+
+.bio-properties-panel-applied-template-button .bio-properties-panel-group-header-button,
+.bio-properties-panel-template-update-available .bio-properties-panel-group-header-button,
+.bio-properties-panel-group-header-button.bio-properties-panel-select-template-button {
+  background-color: var(--select-template-background-color);
+  color: var(--select-template-label-color);
+  fill: var(--select-template-fill-color);
+}
+
+.bio-properties-panel-applied-template-button .bio-properties-panel-group-header-button:hover,
+.bio-properties-panel-template-update-available .bio-properties-panel-group-header-button:hover,
+.bio-properties-panel-group-header-button.bio-properties-panel-select-template-button:hover {
+  background-color: var(--select-template-hover-background-color);
+}
+
+.bio-properties-panel-templates-group .bio-properties-panel-group-header-button * {
+  color: inherit;
+}
+
+.bio-properties-panel-templates-group .bio-properties-panel-group-header-button * + * {
+  margin-left: 2px;
+}
+
+.bio-properties-panel-group-header-button.bio-properties-panel-select-template-button:last-child {
+  padding-right: 9px;
+  padding-left: 6px;
+  margin-right: 22px;
+}
+
+.bio-properties-panel-template-update-available:last-child,
+.bio-properties-panel-applied-template-button:last-child,
+.bio-properties-panel-template-not-found:last-child {
+  margin-right: 32px;
+}
+
+.bio-properties-panel-remove-template {
+  color: var(--text-error-color);
+}
+
+.bio-properties-panel-template-not-found .bio-properties-panel-group-header-button {
+  background-color: var(--unknown-template-background-color);
+  color: var(--select-template-label-color);
+  fill: var(--select-template-fill-color);
+}
+
+.bio-properties-panel-template-not-found .bio-properties-panel-group-header-button:hover {
+  background-color: var(--unknown-template-hover-background-color);
+}
+
+.bio-properties-panel-template-not-found-text,
+.bio-properties-panel-template-update-available-text {
+  color: var(--select-template-information-text-color);
+}
+
+.bio-properties-panel-template-not-found-text,
+.bio-properties-panel-template-update-available-text {
+  width: 216px;
+}

assets/bpmn-js-properties-panel/package.json

@@ -0,0 +1,119 @@
+{
+  "name": "bpmn-js-properties-panel",
+  "version": "1.4.0",
+  "description": "A simple properties panel for bpmn-js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "all": "run-s lint test distro",
+    "distro": "run-s build test:build",
+    "build": "run-p bundle",
+    "bundle": "rollup -c",
+    "bundle:watch": "rollup -c -w",
+    "lint": "eslint .",
+    "dev": "npm test -- --auto-watch --no-single-run",
+    "test": "karma start karma.config.js",
+    "test:build": "mocha --reporter=spec --recursive test/distro",
+    "start": "npm run start:cloud",
+    "start:cloud": "cross-env SINGLE_START=cloud npm run dev",
+    "start:platform": "cross-env SINGLE_START=platform npm run dev",
+    "start:bpmn": "cross-env SINGLE_START=bpmn npm run dev",
+    "start:templates": "cross-env SINGLE_START=templates npm run dev",
+    "start:cloud-templates": "cross-env SINGLE_START=cloud-templates npm run dev",
+    "prepare": "run-s bundle"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bpmn-io/bpmn-js-properties-panel"
+  },
+  "keywords": [
+    "bpmn-io",
+    "bpmn-js",
+    "properties",
+    "properties-panel"
+  ],
+  "main": "dist/index.js",
+  "module": "dist/index.esm.js",
+  "umd:main": "dist/bpmn-js-properties-panel.umd.js",
+  "author": {
+    "name": "Nico Rehwaldt",
+    "url": "https://github.com/nikku"
+  },
+  "contributors": [
+    {
+      "name": "bpmn.io contributors",
+      "url": "https://github.com/bpmn-io"
+    }
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@bpmn-io/element-templates-validator": "^0.9.0",
+    "@bpmn-io/extract-process-variables": "^0.5.0",
+    "array-move": "^3.0.1",
+    "classnames": "^2.3.1",
+    "ids": "^1.0.0",
+    "min-dash": "^3.8.1",
+    "min-dom": "^3.1.3",
+    "preact-markup": "^2.1.1",
+    "semver-compare": "^1.0.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.14.3",
+    "@babel/plugin-transform-react-jsx": "^7.14.3",
+    "@bpmn-io/element-template-chooser": "^0.0.5",
+    "@bpmn-io/element-templates-icons-renderer": "^0.1.2",
+    "@bpmn-io/properties-panel": "^0.18.0",
+    "@rollup/plugin-alias": "^3.1.2",
+    "@rollup/plugin-babel": "^5.3.0",
+    "@rollup/plugin-commonjs": "^19.0.0",
+    "@rollup/plugin-json": "^4.1.0",
+    "@rollup/plugin-node-resolve": "^13.0.0",
+    "@testing-library/preact": "^2.0.1",
+    "@testing-library/preact-hooks": "^1.1.0",
+    "axe-core": "^4.4.2",
+    "babel-loader": "^8.2.2",
+    "bpmn-js": "9.3.1",
+    "bpmn-moddle": "^7.1.2",
+    "camunda-bpmn-js-behaviors": "^0.1.0",
+    "camunda-bpmn-moddle": "^6.1.2",
+    "chai": "^4.3.4",
+    "copy-webpack-plugin": "^9.0.0",
+    "cross-env": "^7.0.3",
+    "css-loader": "^5.2.6",
+    "diagram-js": "^8.6.0",
+    "eslint": "^7.32.0",
+    "eslint-plugin-bpmn-io": "^0.13.0",
+    "eslint-plugin-import": "^2.23.4",
+    "eslint-plugin-react-hooks": "^4.2.0",
+    "istanbul-instrumenter-loader": "^3.0.1",
+    "karma": "^6.3.20",
+    "karma-chrome-launcher": "^3.1.0",
+    "karma-coverage": "^2.0.3",
+    "karma-debug-launcher": "0.0.4",
+    "karma-env-preprocessor": "^0.1.1",
+    "karma-mocha": "^2.0.1",
+    "karma-sinon-chai": "^2.0.2",
+    "karma-webpack": "^5.0.0",
+    "mocha": "^9.2.0",
+    "mocha-test-container-support": "^0.2.0",
+    "npm-run-all": "^4.1.5",
+    "puppeteer": "^10.0.0",
+    "raw-loader": "^4.0.2",
+    "react-svg-loader": "^3.0.3",
+    "rollup": "^2.52.6",
+    "rollup-plugin-copy": "^3.4.0",
+    "rollup-plugin-react-svg": "^3.0.3",
+    "sinon": "^11.1.1",
+    "sinon-chai": "^3.7.0",
+    "sirv-cli": "^1.0.12",
+    "webpack": "^5.38.1",
+    "zeebe-bpmn-moddle": "^0.12.1"
+  },
+  "peerDependencies": {
+    "bpmn-js": "8.x || 9.x",
+    "camunda-bpmn-js-behaviors": "0.1.x",
+    "diagram-js": "7.x || 8.x",
+    "@bpmn-io/properties-panel": "0.18.x"
+  }
+}

assets/bpmn-js/dist/assets/bpmn-font/css/bpmn-codes.css

@@ -0,0 +1,108 @@
+
+.bpmn-icon-screw-wrench:before { content: '\e800'; } /* '' */
+.bpmn-icon-trash:before { content: '\e801'; } /* '' */
+.bpmn-icon-conditional-flow:before { content: '\e802'; } /* '' */
+.bpmn-icon-default-flow:before { content: '\e803'; } /* '' */
+.bpmn-icon-gateway-parallel:before { content: '\e804'; } /* '' */
+.bpmn-icon-intermediate-event-catch-cancel:before { content: '\e805'; } /* '' */
+.bpmn-icon-intermediate-event-catch-non-interrupting-message:before { content: '\e806'; } /* '' */
+.bpmn-icon-start-event-compensation:before { content: '\e807'; } /* '' */
+.bpmn-icon-start-event-non-interrupting-parallel-multiple:before { content: '\e808'; } /* '' */
+.bpmn-icon-loop-marker:before { content: '\e809'; } /* '' */
+.bpmn-icon-parallel-mi-marker:before { content: '\e80a'; } /* '' */
+.bpmn-icon-start-event-non-interrupting-signal:before { content: '\e80b'; } /* '' */
+.bpmn-icon-intermediate-event-catch-non-interrupting-timer:before { content: '\e80c'; } /* '' */
+.bpmn-icon-intermediate-event-catch-parallel-multiple:before { content: '\e80d'; } /* '' */
+.bpmn-icon-intermediate-event-catch-compensation:before { content: '\e80e'; } /* '' */
+.bpmn-icon-gateway-xor:before { content: '\e80f'; } /* '' */
+.bpmn-icon-connection:before { content: '\e810'; } /* '' */
+.bpmn-icon-end-event-cancel:before { content: '\e811'; } /* '' */
+.bpmn-icon-intermediate-event-catch-condition:before { content: '\e812'; } /* '' */
+.bpmn-icon-intermediate-event-catch-non-interrupting-parallel-multiple:before { content: '\e813'; } /* '' */
+.bpmn-icon-start-event-condition:before { content: '\e814'; } /* '' */
+.bpmn-icon-start-event-non-interrupting-timer:before { content: '\e815'; } /* '' */
+.bpmn-icon-sequential-mi-marker:before { content: '\e816'; } /* '' */
+.bpmn-icon-user-task:before { content: '\e817'; } /* '' */
+.bpmn-icon-business-rule:before { content: '\e818'; } /* '' */
+.bpmn-icon-sub-process-marker:before { content: '\e819'; } /* '' */
+.bpmn-icon-start-event-parallel-multiple:before { content: '\e81a'; } /* '' */
+.bpmn-icon-start-event-error:before { content: '\e81b'; } /* '' */
+.bpmn-icon-intermediate-event-catch-signal:before { content: '\e81c'; } /* '' */
+.bpmn-icon-intermediate-event-catch-error:before { content: '\e81d'; } /* '' */
+.bpmn-icon-end-event-compensation:before { content: '\e81e'; } /* '' */
+.bpmn-icon-subprocess-collapsed:before { content: '\e81f'; } /* '' */
+.bpmn-icon-subprocess-expanded:before { content: '\e820'; } /* '' */
+.bpmn-icon-task:before { content: '\e821'; } /* '' */
+.bpmn-icon-end-event-error:before { content: '\e822'; } /* '' */
+.bpmn-icon-intermediate-event-catch-escalation:before { content: '\e823'; } /* '' */
+.bpmn-icon-intermediate-event-catch-timer:before { content: '\e824'; } /* '' */
+.bpmn-icon-start-event-escalation:before { content: '\e825'; } /* '' */
+.bpmn-icon-start-event-signal:before { content: '\e826'; } /* '' */
+.bpmn-icon-business-rule-task:before { content: '\e827'; } /* '' */
+.bpmn-icon-manual:before { content: '\e828'; } /* '' */
+.bpmn-icon-receive:before { content: '\e829'; } /* '' */
+.bpmn-icon-call-activity:before { content: '\e82a'; } /* '' */
+.bpmn-icon-start-event-timer:before { content: '\e82b'; } /* '' */
+.bpmn-icon-start-event-message:before { content: '\e82c'; } /* '' */
+.bpmn-icon-intermediate-event-none:before { content: '\e82d'; } /* '' */
+.bpmn-icon-intermediate-event-catch-link:before { content: '\e82e'; } /* '' */
+.bpmn-icon-end-event-escalation:before { content: '\e82f'; } /* '' */
+.bpmn-icon-text-annotation:before { content: '\e830'; } /* '' */
+.bpmn-icon-bpmn-io:before { content: '\e831'; } /* '' */
+.bpmn-icon-gateway-complex:before { content: '\e832'; } /* '' */
+.bpmn-icon-gateway-eventbased:before { content: '\e833'; } /* '' */
+.bpmn-icon-gateway-none:before { content: '\e834'; } /* '' */
+.bpmn-icon-gateway-or:before { content: '\e835'; } /* '' */
+.bpmn-icon-end-event-terminate:before { content: '\e836'; } /* '' */
+.bpmn-icon-end-event-signal:before { content: '\e837'; } /* '' */
+.bpmn-icon-end-event-none:before { content: '\e838'; } /* '' */
+.bpmn-icon-end-event-multiple:before { content: '\e839'; } /* '' */
+.bpmn-icon-end-event-message:before { content: '\e83a'; } /* '' */
+.bpmn-icon-end-event-link:before { content: '\e83b'; } /* '' */
+.bpmn-icon-intermediate-event-catch-message:before { content: '\e83c'; } /* '' */
+.bpmn-icon-intermediate-event-throw-compensation:before { content: '\e83d'; } /* '' */
+.bpmn-icon-start-event-multiple:before { content: '\e83e'; } /* '' */
+.bpmn-icon-script:before { content: '\e83f'; } /* '' */
+.bpmn-icon-manual-task:before { content: '\e840'; } /* '' */
+.bpmn-icon-send:before { content: '\e841'; } /* '' */
+.bpmn-icon-service:before { content: '\e842'; } /* '' */
+.bpmn-icon-receive-task:before { content: '\e843'; } /* '' */
+.bpmn-icon-user:before { content: '\e844'; } /* '' */
+.bpmn-icon-start-event-none:before { content: '\e845'; } /* '' */
+.bpmn-icon-intermediate-event-throw-escalation:before { content: '\e846'; } /* '' */
+.bpmn-icon-intermediate-event-catch-multiple:before { content: '\e847'; } /* '' */
+.bpmn-icon-intermediate-event-catch-non-interrupting-escalation:before { content: '\e848'; } /* '' */
+.bpmn-icon-intermediate-event-throw-link:before { content: '\e849'; } /* '' */
+.bpmn-icon-start-event-non-interrupting-condition:before { content: '\e84a'; } /* '' */
+.bpmn-icon-data-object:before { content: '\e84b'; } /* '' */
+.bpmn-icon-script-task:before { content: '\e84c'; } /* '' */
+.bpmn-icon-send-task:before { content: '\e84d'; } /* '' */
+.bpmn-icon-data-store:before { content: '\e84e'; } /* '' */
+.bpmn-icon-start-event-non-interrupting-escalation:before { content: '\e84f'; } /* '' */
+.bpmn-icon-intermediate-event-throw-message:before { content: '\e850'; } /* '' */
+.bpmn-icon-intermediate-event-catch-non-interrupting-multiple:before { content: '\e851'; } /* '' */
+.bpmn-icon-intermediate-event-catch-non-interrupting-signal:before { content: '\e852'; } /* '' */
+.bpmn-icon-intermediate-event-throw-multiple:before { content: '\e853'; } /* '' */
+.bpmn-icon-start-event-non-interrupting-message:before { content: '\e854'; } /* '' */
+.bpmn-icon-ad-hoc-marker:before { content: '\e855'; } /* '' */
+.bpmn-icon-service-task:before { content: '\e856'; } /* '' */
+.bpmn-icon-task-none:before { content: '\e857'; } /* '' */
+.bpmn-icon-compensation-marker:before { content: '\e858'; } /* '' */
+.bpmn-icon-start-event-non-interrupting-multiple:before { content: '\e859'; } /* '' */
+.bpmn-icon-intermediate-event-throw-signal:before { content: '\e85a'; } /* '' */
+.bpmn-icon-intermediate-event-catch-non-interrupting-condition:before { content: '\e85b'; } /* '' */
+.bpmn-icon-participant:before { content: '\e85c'; } /* '' */
+.bpmn-icon-event-subprocess-expanded:before { content: '\e85d'; } /* '' */
+.bpmn-icon-lane-insert-below:before { content: '\e85e'; } /* '' */
+.bpmn-icon-space-tool:before { content: '\e85f'; } /* '' */
+.bpmn-icon-connection-multi:before { content: '\e860'; } /* '' */
+.bpmn-icon-lane:before { content: '\e861'; } /* '' */
+.bpmn-icon-lasso-tool:before { content: '\e862'; } /* '' */
+.bpmn-icon-lane-insert-above:before { content: '\e863'; } /* '' */
+.bpmn-icon-lane-divide-three:before { content: '\e864'; } /* '' */
+.bpmn-icon-lane-divide-two:before { content: '\e865'; } /* '' */
+.bpmn-icon-data-input:before { content: '\e866'; } /* '' */
+.bpmn-icon-data-output:before { content: '\e867'; } /* '' */
+.bpmn-icon-hand-tool:before { content: '\e868'; } /* '' */
+.bpmn-icon-group:before { content: '\e869'; } /* '' */
+.bpmn-icon-transaction:before { content: '\e8c4'; } /* '' */

assets/bpmn-js/dist/assets/bpmn-font/css/bpmn.css

@@ -0,0 +1,164 @@
+@font-face {
+  font-family: 'bpmn';
+  src: url('../font/bpmn.eot?26374340');
+  src: url('../font/bpmn.eot?26374340#iefix') format('embedded-opentype'),
+       url('../font/bpmn.woff2?26374340') format('woff2'),
+       url('../font/bpmn.woff?26374340') format('woff'),
+       url('../font/bpmn.ttf?26374340') format('truetype'),
+       url('../font/bpmn.svg?26374340#bpmn') format('svg');
+  font-weight: normal;
+  font-style: normal;
+}
+/* Chrome hack: SVG is rendered more smooth in Windozze. 100% magic, uncomment if you need it. */
+/* Note, that will break hinting! In other OS-es font will be not as sharp as it could be */
+/*
+@media screen and (-webkit-min-device-pixel-ratio:0) {
+  @font-face {
+    font-family: 'bpmn';
+    src: url('../font/bpmn.svg?26374340#bpmn') format('svg');
+  }
+}
+*/
+
+ [class^="bpmn-icon-"]:before, [class*=" bpmn-icon-"]:before {
+  font-family: "bpmn";
+  font-style: normal;
+  font-weight: normal;
+  speak: never;
+
+  display: inline-block;
+  text-decoration: inherit;
+  width: 1em;
+  /* margin-right: .2em; */
+  text-align: center;
+  /* opacity: .8; */
+
+  /* For safety - reset parent styles, that can break glyph codes*/
+  font-variant: normal;
+  text-transform: none;
+
+  /* fix buttons height, for twitter bootstrap */
+  line-height: 1em;
+
+  /* Animation center compensation - margins should be symmetric */
+  /* remove if not needed */
+  /* margin-left: .2em; */
+
+  /* you can be more comfortable with increased icons size */
+  /* font-size: 120%; */
+
+  /* Font smoothing. That was taken from TWBS */
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+
+  /* Uncomment for 3D effect */
+  /* text-shadow: 1px 1px 1px rgba(127, 127, 127, 0.3); */
+}
+
+.bpmn-icon-screw-wrench:before { content: '\e800'; } /* '' */
+.bpmn-icon-trash:before { content: '\e801'; } /* '' */
+.bpmn-icon-conditional-flow:before { content: '\e802'; } /* '' */
+.bpmn-icon-default-flow:before { content: '\e803'; } /* '' */
+.bpmn-icon-gateway-parallel:before { content: '\e804'; } /* '' */
+.bpmn-icon-intermediate-event-catch-cancel:before { content: '\e805'; } /* '' */
+.bpmn-icon-intermediate-event-catch-non-interrupting-message:before { content: '\e806'; } /* '' */
+.bpmn-icon-start-event-compensation:before { content: '\e807'; } /* '' */
+.bpmn-icon-start-event-non-interrupting-parallel-multiple:before { content: '\e808'; } /* '' */
+.bpmn-icon-loop-marker:before { content: '\e809'; } /* '' */
+.bpmn-icon-parallel-mi-marker:before { content: '\e80a'; } /* '' */
+.bpmn-icon-start-event-non-interrupting-signal:before { content: '\e80b'; } /* '' */
+.bpmn-icon-intermediate-event-catch-non-interrupting-timer:before { content: '\e80c'; } /* '' */
+.bpmn-icon-intermediate-event-catch-parallel-multiple:before { content: '\e80d'; } /* '' */
+.bpmn-icon-intermediate-event-catch-compensation:before { content: '\e80e'; } /* '' */
+.bpmn-icon-gateway-xor:before { content: '\e80f'; } /* '' */
+.bpmn-icon-connection:before { content: '\e810'; } /* '' */
+.bpmn-icon-end-event-cancel:before { content: '\e811'; } /* '' */
+.bpmn-icon-intermediate-event-catch-condition:before { content: '\e812'; } /* '' */
+.bpmn-icon-intermediate-event-catch-non-interrupting-parallel-multiple:before { content: '\e813'; } /* '' */
+.bpmn-icon-start-event-condition:before { content: '\e814'; } /* '' */
+.bpmn-icon-start-event-non-interrupting-timer:before { content: '\e815'; } /* '' */
+.bpmn-icon-sequential-mi-marker:before { content: '\e816'; } /* '' */
+.bpmn-icon-user-task:before { content: '\e817'; } /* '' */
+.bpmn-icon-business-rule:before { content: '\e818'; } /* '' */
+.bpmn-icon-sub-process-marker:before { content: '\e819'; } /* '' */
+.bpmn-icon-start-event-parallel-multiple:before { content: '\e81a'; } /* '' */
+.bpmn-icon-start-event-error:before { content: '\e81b'; } /* '' */
+.bpmn-icon-intermediate-event-catch-signal:before { content: '\e81c'; } /* '' */
+.bpmn-icon-intermediate-event-catch-error:before { content: '\e81d'; } /* '' */
+.bpmn-icon-end-event-compensation:before { content: '\e81e'; } /* '' */
+.bpmn-icon-subprocess-collapsed:before { content: '\e81f'; } /* '' */
+.bpmn-icon-subprocess-expanded:before { content: '\e820'; } /* '' */
+.bpmn-icon-task:before { content: '\e821'; } /* '' */
+.bpmn-icon-end-event-error:before { content: '\e822'; } /* '' */
+.bpmn-icon-intermediate-event-catch-escalation:before { content: '\e823'; } /* '' */
+.bpmn-icon-intermediate-event-catch-timer:before { content: '\e824'; } /* '' */
+.bpmn-icon-start-event-escalation:before { content: '\e825'; } /* '' */
+.bpmn-icon-start-event-signal:before { content: '\e826'; } /* '' */
+.bpmn-icon-business-rule-task:before { content: '\e827'; } /* '' */
+.bpmn-icon-manual:before { content: '\e828'; } /* '' */
+.bpmn-icon-receive:before { content: '\e829'; } /* '' */
+.bpmn-icon-call-activity:before { content: '\e82a'; } /* '' */
+.bpmn-icon-start-event-timer:before { content: '\e82b'; } /* '' */
+.bpmn-icon-start-event-message:before { content: '\e82c'; } /* '' */
+.bpmn-icon-intermediate-event-none:before { content: '\e82d'; } /* '' */
+.bpmn-icon-intermediate-event-catch-link:before { content: '\e82e'; } /* '' */
+.bpmn-icon-end-event-escalation:before { content: '\e82f'; } /* '' */
+.bpmn-icon-text-annotation:before { content: '\e830'; } /* '' */
+.bpmn-icon-bpmn-io:before { content: '\e831'; } /* '' */
+.bpmn-icon-gateway-complex:before { content: '\e832'; } /* '' */
+.bpmn-icon-gateway-eventbased:before { content: '\e833'; } /* '' */
+.bpmn-icon-gateway-none:before { content: '\e834'; } /* '' */
+.bpmn-icon-gateway-or:before { content: '\e835'; } /* '' */
+.bpmn-icon-end-event-terminate:before { content: '\e836'; } /* '' */
+.bpmn-icon-end-event-signal:before { content: '\e837'; } /* '' */
+.bpmn-icon-end-event-none:before { content: '\e838'; } /* '' */
+.bpmn-icon-end-event-multiple:before { content: '\e839'; } /* '' */
+.bpmn-icon-end-event-message:before { content: '\e83a'; } /* '' */
+.bpmn-icon-end-event-link:before { content: '\e83b'; } /* '' */
+.bpmn-icon-intermediate-event-catch-message:before { content: '\e83c'; } /* '' */
+.bpmn-icon-intermediate-event-throw-compensation:before { content: '\e83d'; } /* '' */
+.bpmn-icon-start-event-multiple:before { content: '\e83e'; } /* '' */
+.bpmn-icon-script:before { content: '\e83f'; } /* '' */
+.bpmn-icon-manual-task:before { content: '\e840'; } /* '' */
+.bpmn-icon-send:before { content: '\e841'; } /* '' */
+.bpmn-icon-service:before { content: '\e842'; } /* '' */
+.bpmn-icon-receive-task:before { content: '\e843'; } /* '' */
+.bpmn-icon-user:before { content: '\e844'; } /* '' */
+.bpmn-icon-start-event-none:before { content: '\e845'; } /* '' */
+.bpmn-icon-intermediate-event-throw-escalation:before { content: '\e846'; } /* '' */
+.bpmn-icon-intermediate-event-catch-multiple:before { content: '\e847'; } /* '' */
+.bpmn-icon-intermediate-event-catch-non-interrupting-escalation:before { content: '\e848'; } /* '' */
+.bpmn-icon-intermediate-event-throw-link:before { content: '\e849'; } /* '' */
+.bpmn-icon-start-event-non-interrupting-condition:before { content: '\e84a'; } /* '' */
+.bpmn-icon-data-object:before { content: '\e84b'; } /* '' */
+.bpmn-icon-script-task:before { content: '\e84c'; } /* '' */
+.bpmn-icon-send-task:before { content: '\e84d'; } /* '' */
+.bpmn-icon-data-store:before { content: '\e84e'; } /* '' */
+.bpmn-icon-start-event-non-interrupting-escalation:before { content: '\e84f'; } /* '' */
+.bpmn-icon-intermediate-event-throw-message:before { content: '\e850'; } /* '' */
+.bpmn-icon-intermediate-event-catch-non-interrupting-multiple:before { content: '\e851'; } /* '' */
+.bpmn-icon-intermediate-event-catch-non-interrupting-signal:before { content: '\e852'; } /* '' */
+.bpmn-icon-intermediate-event-throw-multiple:before { content: '\e853'; } /* '' */
+.bpmn-icon-start-event-non-interrupting-message:before { content: '\e854'; } /* '' */
+.bpmn-icon-ad-hoc-marker:before { content: '\e855'; } /* '' */
+.bpmn-icon-service-task:before { content: '\e856'; } /* '' */
+.bpmn-icon-task-none:before { content: '\e857'; } /* '' */
+.bpmn-icon-compensation-marker:before { content: '\e858'; } /* '' */
+.bpmn-icon-start-event-non-interrupting-multiple:before { content: '\e859'; } /* '' */
+.bpmn-icon-intermediate-event-throw-signal:before { content: '\e85a'; } /* '' */
+.bpmn-icon-intermediate-event-catch-non-interrupting-condition:before { content: '\e85b'; } /* '' */
+.bpmn-icon-participant:before { content: '\e85c'; } /* '' */
+.bpmn-icon-event-subprocess-expanded:before { content: '\e85d'; } /* '' */
+.bpmn-icon-lane-insert-below:before { content: '\e85e'; } /* '' */
+.bpmn-icon-space-tool:before { content: '\e85f'; } /* '' */
+.bpmn-icon-connection-multi:before { content: '\e860'; } /* '' */
+.bpmn-icon-lane:before { content: '\e861'; } /* '' */
+.bpmn-icon-lasso-tool:before { content: '\e862'; } /* '' */
+.bpmn-icon-lane-insert-above:before { content: '\e863'; } /* '' */
+.bpmn-icon-lane-divide-three:before { content: '\e864'; } /* '' */
+.bpmn-icon-lane-divide-two:before { content: '\e865'; } /* '' */
+.bpmn-icon-data-input:before { content: '\e866'; } /* '' */
+.bpmn-icon-data-output:before { content: '\e867'; } /* '' */
+.bpmn-icon-hand-tool:before { content: '\e868'; } /* '' */
+.bpmn-icon-group:before { content: '\e869'; } /* '' */
+.bpmn-icon-transaction:before { content: '\e8c4'; } /* '' */

assets/bpmn-js/dist/assets/bpmn-js.css

@@ -0,0 +1,116 @@
+.bjs-container {
+  --bjs-font-family: Arial, sans-serif;
+
+  --color-grey-225-10-15: hsl(225, 10%, 15%);
+  --color-grey-225-10-35: hsl(225, 10%, 35%);
+  --color-grey-225-10-55: hsl(225, 10%, 55%);
+  --color-grey-225-10-75: hsl(225, 10%, 75%);
+  --color-grey-225-10-80: hsl(225, 10%, 80%);
+  --color-grey-225-10-85: hsl(225, 10%, 85%);
+  --color-grey-225-10-90: hsl(225, 10%, 90%);
+  --color-grey-225-10-95: hsl(225, 10%, 95%); 
+  --color-grey-225-10-97: hsl(225, 10%, 97%);
+
+  --color-blue-205-100-45: hsl(205, 100%, 45%);
+  --color-blue-205-100-45-opacity-30: hsla(205, 100%, 45%, 30%);
+  --color-blue-205-100-50: hsl(205, 100%, 50%);
+  --color-blue-205-100-95: hsl(205, 100%, 95%);
+
+  --color-green-150-86-44: hsl(150, 86%, 44%);
+
+  --color-red-360-100-40: hsl(360, 100%, 40%);
+  --color-red-360-100-45: hsl(360, 100%, 45%);
+  --color-red-360-100-92: hsl(360, 100%, 92%);
+  --color-red-360-100-97: hsl(360, 100%, 97%);
+
+  --color-white: hsl(0, 0%, 100%);
+  --color-black: hsl(0, 0%, 0%); 
+  --color-black-opacity-05: hsla(0, 0%, 0%, 5%); 
+  --color-black-opacity-10: hsla(0, 0%, 0%, 10%);
+
+  --breadcrumbs-font-family: var(--bjs-font-family);
+  --breadcrumbs-item-color: var(--color-blue-205-100-50);
+  --breadcrumbs-arrow-color: var(--color-black);
+  --drilldown-fill-color: var(--color-white);
+  --drilldown-background-color: var(--color-blue-205-100-50);
+}
+
+.bjs-breadcrumbs {
+  position: absolute;
+  display: none;
+  flex-wrap: wrap;
+  align-items: center;
+  top: 30px;
+  left: 30px;
+  padding: 0px;
+  margin: 0px;
+  font-family: var(--breadcrumbs-font-family);
+  font-size: 16px;
+  line-height: normal;
+}
+
+.bjs-breadcrumbs-shown .bjs-breadcrumbs {
+  display: flex;
+}
+
+.djs-palette-shown .bjs-breadcrumbs {
+  left: 90px;
+}
+
+.djs-palette-shown.djs-palette-two-column .bjs-breadcrumbs {
+  left: 140px;
+}
+
+.bjs-breadcrumbs li {
+  display: inline-flex;
+  padding-bottom: 5px;
+}
+
+.bjs-breadcrumbs li a {
+  cursor: pointer;
+  color: var(--breadcrumbs-item-color);
+}
+
+.bjs-breadcrumbs li:last-of-type a {
+  color: inherit;
+  cursor: default;
+}
+
+.bjs-breadcrumbs li:not(:first-child)::before {
+  content: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" width="17" height="17" viewBox="0 0 24 24"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z" /><path d="M0 0h24v24H0z" fill="none" /></svg>');
+  padding: 0 8px;
+  color: var(--breadcrumbs-arrow-color);
+  height: 1em;
+}
+
+.bjs-breadcrumbs .bjs-crumb {
+  display: inline-block;
+  max-width: 200px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.bjs-drilldown {
+  width: 20px;
+  height: 20px;
+
+  padding: 0px;
+  margin-left: -20px;
+
+  cursor: pointer;
+  border: none;
+  border-radius: 2px;
+  outline: none;
+
+  fill: var(--drilldown-fill-color);
+  background-color: var(--drilldown-background-color);
+}
+
+.bjs-drilldown-empty {
+  display: none;
+}
+
+.selected .bjs-drilldown-empty {
+  display: inherit;
+}

assets/bpmn-js/dist/assets/diagram-js.css

@@ -0,0 +1,823 @@
+/**
+ * color definitions
+ */
+.djs-container {
+  --color-grey-225-10-15: hsl(225, 10%, 15%);
+  --color-grey-225-10-35: hsl(225, 10%, 35%);
+  --color-grey-225-10-55: hsl(225, 10%, 55%);
+  --color-grey-225-10-75: hsl(225, 10%, 75%);
+  --color-grey-225-10-80: hsl(225, 10%, 80%);
+  --color-grey-225-10-85: hsl(225, 10%, 85%);
+  --color-grey-225-10-90: hsl(225, 10%, 90%);
+  --color-grey-225-10-95: hsl(225, 10%, 95%);
+  --color-grey-225-10-97: hsl(225, 10%, 97%);
+
+  --color-blue-205-100-45: hsl(205, 100%, 45%);
+  --color-blue-205-100-45-opacity-30: hsla(205, 100%, 45%, 30%);
+  --color-blue-205-100-50: hsl(205, 100%, 50%);
+  --color-blue-205-100-50-opacity-15: hsla(205, 100%, 50%, 15%);
+  --color-blue-205-100-70: hsl(205, 100%, 75%);
+  --color-blue-205-100-95: hsl(205, 100%, 95%);
+
+  --color-green-150-86-44: hsl(150, 86%, 44%);
+
+  --color-red-360-100-40: hsl(360, 100%, 40%);
+  --color-red-360-100-45: hsl(360, 100%, 45%);
+  --color-red-360-100-92: hsl(360, 100%, 92%);
+  --color-red-360-100-97: hsl(360, 100%, 97%);
+
+  --color-white: hsl(0, 0%, 100%);
+  --color-black: hsl(0, 0%, 0%);
+  --color-black-opacity-10: hsla(0, 0%, 0%, 10%);
+
+  --canvas-fill-color: var(--color-white);
+
+  --bendpoint-fill-color: var(--color-blue-205-100-45);
+  --bendpoint-stroke-color: var(--canvas-fill-color);
+
+  --context-pad-entry-background-color: var(--color-white);
+  --context-pad-entry-hover-background-color: var(--color-grey-225-10-95);
+
+  --element-dragger-color: var(--color-blue-205-100-50);
+  --element-hover-outline-fill-color: var(--color-blue-205-100-45);
+  --element-selected-outline-stroke-color: var(--color-blue-205-100-50);
+  --element-selected-outline-secondary-stroke-color: var(--color-blue-205-100-70);
+
+  --lasso-fill-color: var(--color-blue-205-100-50-opacity-15);
+  --lasso-stroke-color: var(--element-selected-outline-stroke-color);
+
+  --palette-entry-color: var(--color-grey-225-10-15);
+  --palette-entry-hover-color: var(--color-blue-205-100-45);
+  --palette-entry-selected-color: var(--color-blue-205-100-50);
+  --palette-separator-color: var(--color-grey-225-10-75);
+  --palette-toggle-hover-background-color: var(--color-grey-225-10-55);
+  --palette-background-color: var(--color-grey-225-10-97);
+  --palette-border-color: var(--color-grey-225-10-75);
+
+  --popup-body-background-color: var(--color-white);
+  --popup-header-entry-selected-color: var(--color-blue-205-100-50);
+  --popup-header-entry-selected-background-color: var(--color-black-opacity-10);
+  --popup-header-separator-color: var(--color-grey-225-10-75);
+  --popup-background-color: var(--color-grey-225-10-97);
+  --popup-border-color: var(--color-grey-225-10-75);
+
+  --resizer-fill-color: var(--color-blue-205-100-45);
+  --resizer-stroke-color: var(--canvas-fill-color);
+
+  --search-container-background-color: var(--color-grey-225-10-97);
+  --search-container-border-color: var(--color-blue-205-100-50);
+  --search-container-box-shadow-color: var(--color-blue-205-100-95);
+  --search-container-box-shadow-inset-color: var(--color-grey-225-10-80);
+  --search-input-border-color: var(--color-grey-225-10-75);
+  --search-result-border-color: var(--color-grey-225-10-75);
+  --search-result-highlight-color: var(--color-black);
+  --search-result-selected-color: var(--color-blue-205-100-45-opacity-30);
+
+  --shape-attach-allowed-stroke-color: var(--color-blue-205-100-50);
+  --shape-connect-allowed-fill-color: var(--color-grey-225-10-97);
+  --shape-drop-allowed-fill-color: var(--color-grey-225-10-97);
+  --shape-drop-not-allowed-fill-color: var(--color-red-360-100-97);
+  --shape-resize-preview-stroke-color: var(--color-blue-205-100-50);
+
+  --snap-line-stroke-color: var(--color-blue-205-100-45-opacity-30);
+
+  --space-tool-crosshair-stroke-color: var(--color-black);
+
+  --tooltip-error-background-color: var(--color-red-360-100-97);
+  --tooltip-error-border-color: var(--color-red-360-100-45);
+  --tooltip-error-color: var(--color-red-360-100-45);
+}
+
+/**
+ * outline styles
+ */
+
+.djs-outline,
+.djs-selection-outline {
+  fill: none;
+  shape-rendering: geometricPrecision;
+  stroke-width: 2px;
+}
+
+.djs-outline {
+  visibility: hidden;
+}
+
+.djs-selection-outline {
+  stroke: var(--element-selected-outline-stroke-color);
+}
+
+.djs-element.selected .djs-outline {
+  visibility: visible;
+
+  stroke: var(--element-selected-outline-stroke-color);
+}
+
+.djs-multi-select .djs-element.selected .djs-outline {
+  stroke: var(--element-selected-outline-secondary-stroke-color);
+}
+
+.djs-shape.connect-ok .djs-visual > :nth-child(1) {
+  fill: var(--shape-connect-allowed-fill-color) !important;
+}
+
+.djs-shape.connect-not-ok .djs-visual > :nth-child(1),
+.djs-shape.drop-not-ok .djs-visual > :nth-child(1) {
+  fill: var(--shape-drop-not-allowed-fill-color) !important;
+}
+
+.djs-shape.new-parent .djs-visual > :nth-child(1) {
+  fill: var(--shape-drop-allowed-fill-color) !important;
+}
+
+svg.drop-not-ok {
+  background: var(--shape-drop-not-allowed-fill-color) !important;
+}
+
+svg.new-parent {
+  background: var(--shape-drop-allowed-fill-color) !important;
+}
+
+
+/* Override move cursor during drop and connect */
+.drop-not-ok,
+.connect-not-ok,
+.drop-not-ok *,
+.connect-not-ok * {
+  cursor: not-allowed !important;
+}
+
+.drop-ok,
+.connect-ok,
+.drop-ok *,
+.connect-ok * {
+  cursor: default !important;
+}
+
+.djs-element.attach-ok .djs-visual > :nth-child(1) {
+  stroke-width: 5px !important;
+  stroke: var(--shape-attach-allowed-stroke-color) !important;
+}
+
+.djs-frame.connect-not-ok .djs-visual > :nth-child(1),
+.djs-frame.drop-not-ok .djs-visual > :nth-child(1) {
+  stroke-width: 3px !important;
+  stroke: var(--shape-drop-not-allowed-fill-color) !important;
+  fill: none !important;
+}
+
+/**
+* Selection box style
+*
+*/
+.djs-lasso-overlay {
+  fill: var(--lasso-fill-color);
+  stroke: var(--lasso-stroke-color);
+  stroke-width: 2px;
+  shape-rendering: geometricPrecision;
+  pointer-events: none;
+}
+
+/**
+ * Resize styles
+ */
+.djs-resize-overlay {
+  fill: none;
+
+  stroke-dasharray: 5 1 3 1;
+  stroke: var(--shape-resize-preview-stroke-color);
+
+  pointer-events: none;
+}
+
+.djs-resizer-hit {
+  fill: none;
+  pointer-events: all;
+}
+
+.djs-resizer-visual {
+  fill: var(--resizer-fill-color);
+  stroke-width: 1px;
+  stroke: var(--resizer-stroke-color);
+  shape-rendering: geometricPrecision;
+}
+
+.djs-resizer:hover .djs-resizer-visual {
+  stroke: var(--resizer-stroke-color);
+  stroke-opacity: 1;
+}
+
+.djs-cursor-resize-ns,
+.djs-resizer-n,
+.djs-resizer-s {
+  cursor: ns-resize;
+}
+
+.djs-cursor-resize-ew,
+.djs-resizer-e,
+.djs-resizer-w {
+  cursor: ew-resize;
+}
+
+.djs-cursor-resize-nwse,
+.djs-resizer-nw,
+.djs-resizer-se {
+  cursor: nwse-resize;
+}
+
+.djs-cursor-resize-nesw,
+.djs-resizer-ne,
+.djs-resizer-sw {
+  cursor: nesw-resize;
+}
+
+.djs-shape.djs-resizing > .djs-outline {
+  visibility: hidden !important;
+}
+
+.djs-shape.djs-resizing > .djs-resizer {
+  visibility: hidden;
+}
+
+.djs-dragger > .djs-resizer {
+  visibility: hidden;
+}
+
+/**
+ * drag styles
+ */
+.djs-dragger * {
+  fill: none !important;
+  stroke: var(--element-dragger-color) !important;
+}
+
+.djs-dragger tspan,
+.djs-dragger text {
+  fill: var(--element-dragger-color) !important;
+  stroke: none !important;
+}
+
+marker.djs-dragger circle,
+marker.djs-dragger path,
+marker.djs-dragger polygon,
+marker.djs-dragger polyline,
+marker.djs-dragger rect {
+  fill: var(--element-dragger-color) !important;
+  stroke: none !important;
+}
+
+marker.djs-dragger text,
+marker.djs-dragger tspan {
+  fill: none !important;
+  stroke: var(--element-dragger-color) !important;
+}
+
+.djs-dragging {
+  opacity: 0.3;
+}
+
+.djs-dragging,
+.djs-dragging > * {
+  pointer-events: none !important;
+}
+
+.djs-dragging .djs-context-pad,
+.djs-dragging .djs-outline {
+  display: none !important;
+}
+
+/**
+ * no pointer events for visual
+ */
+.djs-visual,
+.djs-outline {
+  pointer-events: none;
+}
+
+.djs-element.attach-ok .djs-hit {
+  stroke-width: 60px !important;
+}
+
+/**
+ * all pointer events for hit shape
+ */
+.djs-element > .djs-hit-all,
+.djs-element > .djs-hit-no-move {
+  pointer-events: all;
+}
+
+.djs-element > .djs-hit-stroke,
+.djs-element > .djs-hit-click-stroke {
+  pointer-events: stroke;
+}
+
+/**
+ * shape / connection basic styles
+ */
+.djs-connection .djs-visual {
+  stroke-width: 2px;
+  fill: none;
+}
+
+.djs-cursor-grab {
+  cursor: -webkit-grab;
+  cursor: -moz-grab;
+  cursor: grab;
+}
+
+.djs-cursor-grabbing {
+  cursor: -webkit-grabbing;
+  cursor: -moz-grabbing;
+  cursor: grabbing;
+}
+
+.djs-cursor-crosshair {
+  cursor: crosshair;
+}
+
+.djs-cursor-move {
+  cursor: move;
+}
+
+.djs-cursor-resize-ns {
+  cursor: ns-resize;
+}
+
+.djs-cursor-resize-ew {
+  cursor: ew-resize;
+}
+
+
+/**
+ * snapping
+ */
+.djs-snap-line {
+  stroke: var(--snap-line-stroke-color);
+  stroke-linecap: round;
+  stroke-width: 2px;
+  pointer-events: none;
+}
+
+/**
+ * snapping
+ */
+.djs-crosshair {
+  stroke: var(--space-tool-crosshair-stroke-color);
+  stroke-linecap: round;
+  stroke-width: 1px;
+  pointer-events: none;
+  shape-rendering: geometricPrecision;
+  stroke-dasharray: 5, 5;
+}
+
+/**
+ * palette
+ */
+
+.djs-palette {
+  position: absolute;
+  left: 20px;
+  top: 20px;
+
+  box-sizing: border-box;
+  width: 48px;
+}
+
+.djs-palette .separator {
+  margin: 5px;
+  padding-top: 5px;
+
+  border: none;
+  border-bottom: solid 1px var(--palette-separator-color);
+
+  clear: both;
+}
+
+.djs-palette .entry:before {
+  vertical-align: initial;
+}
+
+.djs-palette .djs-palette-toggle {
+  cursor: pointer;
+}
+
+.djs-palette .entry,
+.djs-palette .djs-palette-toggle {
+  color: var(--palette-entry-color);
+  font-size: 30px;
+
+  text-align: center;
+}
+
+.djs-palette .entry {
+  float: left;
+}
+
+.djs-palette .entry img {
+  max-width: 100%;
+}
+
+.djs-palette .djs-palette-entries:after {
+  content: '';
+  display: table;
+  clear: both;
+}
+
+.djs-palette .djs-palette-toggle:hover {
+  background: var(--palette-toggle-hover-background-color);
+}
+
+.djs-palette .entry:hover {
+  color: var(--palette-entry-hover-color);
+}
+
+.djs-palette .highlighted-entry {
+  color: var(--palette-entry-selected-color) !important;
+}
+
+.djs-palette .entry,
+.djs-palette .djs-palette-toggle {
+  width: 46px;
+  height: 46px;
+  line-height: 46px;
+  cursor: default;
+}
+
+/**
+ * Palette open / two-column layout is controlled via
+ * classes on the palette. Events to hook into palette
+ * changed life-cycle are available in addition.
+ */
+.djs-palette.two-column.open {
+  width: 94px;
+}
+
+.djs-palette:not(.open) .djs-palette-entries {
+  display: none;
+}
+
+.djs-palette:not(.open) {
+  overflow: hidden;
+}
+
+.djs-palette.open .djs-palette-toggle {
+  display: none;
+}
+
+/**
+ * context-pad
+ */
+.djs-overlay-context-pad {
+  width: 72px;
+  z-index: 100;
+}
+
+.djs-context-pad {
+  position: absolute;
+  display: none;
+  pointer-events: none;
+  line-height: 1;
+}
+
+.djs-context-pad .entry {
+  width: 22px;
+  height: 22px;
+  text-align: center;
+  display: inline-block;
+  font-size: 22px;
+  margin: 0 2px 2px 0;
+
+  border-radius: 3px;
+
+  cursor: default;
+
+  background-color: var(--context-pad-entry-background-color);
+  box-shadow: 0 0 2px 1px var(--context-pad-entry-background-color);
+  pointer-events: all;
+  vertical-align: middle;
+}
+
+.djs-context-pad .entry:hover {
+  background: var(--context-pad-entry-hover-background-color);
+}
+
+.djs-context-pad.open {
+  display: block;
+}
+
+/**
+ * popup styles
+ */
+.djs-popup .entry {
+  line-height: 20px;
+  white-space: nowrap;
+  cursor: default;
+}
+
+/* larger font for prefixed icons */
+.djs-popup .entry:before {
+  vertical-align: middle;
+  font-size: 20px;
+}
+
+.djs-popup .entry > span {
+  vertical-align: middle;
+  font-size: 14px;
+}
+
+.djs-popup .entry:hover,
+.djs-popup .entry.active:hover {
+  background: var(--popup-header-entry-selected-background-color);
+}
+
+.djs-popup .entry.disabled {
+  background: inherit;
+}
+
+.djs-popup .djs-popup-header .entry {
+  display: inline-block;
+  padding: 2px 3px 2px 3px;
+
+  border: solid 1px transparent;
+  border-radius: 3px;
+}
+
+.djs-popup .djs-popup-header .entry.active {
+  color: var(--popup-header-entry-selected-color);
+  border: solid 1px var(--popup-header-entry-selected-color);
+  background-color: var(--popup-header-entry-selected-background-color);
+}
+
+.djs-popup-body .entry {
+  padding: 4px 5px;
+}
+
+.djs-popup-body .entry > span {
+  margin-left: 5px;
+}
+
+.djs-popup-body {
+  background-color: var(--popup-body-background-color);
+}
+
+.djs-popup-header {
+  border-bottom: 1px solid var(--popup-header-separator-color);
+}
+
+.djs-popup-header .entry {
+  margin: 1px;
+  margin-left: 3px;
+}
+
+.djs-popup-header .entry:last-child {
+  margin-right: 3px;
+}
+
+/**
+ * popup / palette styles
+ */
+.djs-palette {
+  background: var(--palette-background-color);
+  border: solid 1px var(--palette-border-color);
+  border-radius: 2px;
+}
+
+.djs-popup {
+  background: var(--popup-background-color);
+  border: solid 1px var(--popup-border-color);
+  border-radius: 2px;
+}
+
+/**
+ * touch
+ */
+
+.djs-shape,
+.djs-connection {
+  touch-action: none;
+}
+
+.djs-segment-dragger,
+.djs-bendpoint {
+  display: none;
+}
+
+/**
+ * bendpoints
+ */
+.djs-segment-dragger .djs-visual {
+  display: none;
+
+  fill: var(--bendpoint-fill-color);
+  stroke: var(--bendpoint-stroke-color);
+  stroke-width: 1px;
+  stroke-opacity: 1;
+}
+
+.djs-segment-dragger:hover .djs-visual {
+  display: block;
+}
+
+.djs-bendpoint .djs-visual {
+  fill: var(--bendpoint-fill-color);
+  stroke: var(--bendpoint-stroke-color);
+  stroke-width: 1px;
+}
+
+.djs-segment-dragger:hover,
+.djs-bendpoints.hover .djs-segment-dragger,
+.djs-bendpoints.selected .djs-segment-dragger,
+.djs-bendpoint:hover,
+.djs-bendpoints.hover .djs-bendpoint,
+.djs-bendpoints.selected .djs-bendpoint {
+  display: block;
+}
+
+.djs-drag-active .djs-bendpoints * {
+  display: none;
+}
+
+.djs-bendpoints:not(.hover) .floating {
+  display: none;
+}
+
+.djs-segment-dragger:hover .djs-visual,
+.djs-segment-dragger.djs-dragging .djs-visual,
+.djs-bendpoint:hover .djs-visual,
+.djs-bendpoint.floating .djs-visual {
+  fill: var(--bendpoint-fill-color);
+  stroke: var(--bendpoint-stroke-color);
+  stroke-opacity: 1;
+}
+
+.djs-bendpoint.floating .djs-hit {
+  pointer-events: none;
+}
+
+.djs-segment-dragger .djs-hit,
+.djs-bendpoint .djs-hit {
+  fill: none;
+  pointer-events: all;
+}
+
+.djs-segment-dragger.horizontal .djs-hit {
+  cursor: ns-resize;
+}
+
+.djs-segment-dragger.vertical .djs-hit {
+  cursor: ew-resize;
+}
+
+.djs-segment-dragger.djs-dragging .djs-hit {
+  pointer-events: none;
+}
+
+.djs-updating,
+.djs-updating > * {
+  pointer-events: none !important;
+}
+
+.djs-updating .djs-context-pad,
+.djs-updating .djs-outline,
+.djs-updating .djs-bendpoint,
+.djs-multi-select .djs-bendpoint,
+.djs-multi-select .djs-segment-dragger,
+.connect-ok .djs-bendpoint,
+.connect-not-ok .djs-bendpoint,
+.drop-ok .djs-bendpoint,
+.drop-not-ok .djs-bendpoint {
+  display: none !important;
+}
+
+.djs-segment-dragger.djs-dragging,
+.djs-bendpoint.djs-dragging {
+  display: block;
+  opacity: 1.0;
+}
+
+
+/**
+ * tooltips
+ */
+.djs-tooltip-error {
+  width: 160px;
+  padding: 6px;
+
+  background: var(--tooltip-error-background-color);
+  border: solid 1px var(--tooltip-error-border-color);
+  border-radius: 2px;
+  color: var(--tooltip-error-color);
+  font-size: 12px;
+  line-height: 16px;
+
+  opacity: 0.75;
+}
+
+.djs-tooltip-error:hover {
+  opacity: 1;
+}
+
+
+/**
+ * search pad
+ */
+.djs-search-container {
+  position: absolute;
+  top: 20px;
+  left: 0;
+  right: 0;
+  margin-left: auto;
+  margin-right: auto;
+
+  width: 25%;
+  min-width: 300px;
+  max-width: 400px;
+  z-index: 10;
+
+  font-size: 1.05em;
+  opacity: 0.9;
+  background: var(--search-container-background-color);
+  border: solid 1px var(--search-container-border-color);
+  border-radius: 2px;
+  box-shadow: 0 0 0 2px var(--search-container-box-shadow-color), 0 0 0 1px var(--search-container-box-shadow-inset-color) inset;
+}
+
+.djs-search-container:not(.open) {
+  display: none;
+}
+
+.djs-search-input input {
+  font-size: 1.05em;
+  width: 100%;
+  padding: 6px 10px;
+  border: 1px solid var(--search-input-border-color);
+  box-sizing: border-box;
+}
+
+.djs-search-input input:focus {
+  outline: none;
+  border-color: var(--search-input-border-color);
+}
+
+.djs-search-results {
+  position: relative;
+  overflow-y: auto;
+  max-height: 200px;
+}
+
+.djs-search-results:hover {
+  cursor: pointer;
+}
+
+.djs-search-result {
+  width: 100%;
+  padding: 6px 10px;
+  background: white;
+  border-bottom: solid 1px var(--search-result-border-color);
+  border-radius: 1px;
+}
+
+.djs-search-highlight {
+  color: var(--search-result-highlight-color);
+}
+
+.djs-search-result-primary {
+  margin: 0 0 10px;
+}
+
+.djs-search-result-secondary {
+  font-family: monospace;
+  margin: 0;
+}
+
+.djs-search-result:hover {
+  background: var(--search-result-selected-color);
+}
+
+.djs-search-result-selected {
+  background: var(--search-result-selected-color);
+}
+
+.djs-search-result-selected:hover {
+  background: var(--search-result-selected-color);
+}
+
+.djs-search-overlay {
+  background: var(--search-result-selected-color);
+}
+
+/**
+ * hidden styles
+ */
+.djs-element-hidden,
+.djs-element-hidden .djs-hit,
+.djs-element-hidden .djs-outline,
+.djs-label-hidden .djs-label {
+  display: none !important;
+}
+
+.djs-element .djs-hit-stroke,
+.djs-element .djs-hit-click-stroke,
+.djs-element .djs-hit-all {
+  cursor: move;
+}

assets/clipboard/clipboard.js

@@ -0,0 +1,890 @@
+/*!
+ * clipboard.js v2.0.11
+ * https://clipboardjs.com/
+ *
+ * Licensed MIT © Zeno Rocha
+ */
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else if(typeof exports === 'object')
+		exports["ClipboardJS"] = factory();
+	else
+		root["ClipboardJS"] = factory();
+})(this, function() {
+return /******/ (function() { // webpackBootstrap
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 686:
+/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "default": function() { return /* binding */ clipboard; }
+});
+
+// EXTERNAL MODULE: ./node_modules/tiny-emitter/index.js
+var tiny_emitter = __webpack_require__(279);
+var tiny_emitter_default = /*#__PURE__*/__webpack_require__.n(tiny_emitter);
+// EXTERNAL MODULE: ./node_modules/good-listener/src/listen.js
+var listen = __webpack_require__(370);
+var listen_default = /*#__PURE__*/__webpack_require__.n(listen);
+// EXTERNAL MODULE: ./node_modules/select/src/select.js
+var src_select = __webpack_require__(817);
+var select_default = /*#__PURE__*/__webpack_require__.n(src_select);
+;// CONCATENATED MODULE: ./src/common/command.js
+/**
+ * Executes a given operation type.
+ * @param {String} type
+ * @return {Boolean}
+ */
+function command(type) {
+  try {
+    return document.execCommand(type);
+  } catch (err) {
+    return false;
+  }
+}
+;// CONCATENATED MODULE: ./src/actions/cut.js
+
+
+/**
+ * Cut action wrapper.
+ * @param {String|HTMLElement} target
+ * @return {String}
+ */
+
+var ClipboardActionCut = function ClipboardActionCut(target) {
+  var selectedText = select_default()(target);
+  command('cut');
+  return selectedText;
+};
+
+/* harmony default export */ var actions_cut = (ClipboardActionCut);
+;// CONCATENATED MODULE: ./src/common/create-fake-element.js
+/**
+ * Creates a fake textarea element with a value.
+ * @param {String} value
+ * @return {HTMLElement}
+ */
+function createFakeElement(value) {
+  var isRTL = document.documentElement.getAttribute('dir') === 'rtl';
+  var fakeElement = document.createElement('textarea'); // Prevent zooming on iOS
+
+  fakeElement.style.fontSize = '12pt'; // Reset box model
+
+  fakeElement.style.border = '0';
+  fakeElement.style.padding = '0';
+  fakeElement.style.margin = '0'; // Move element out of screen horizontally
+
+  fakeElement.style.position = 'absolute';
+  fakeElement.style[isRTL ? 'right' : 'left'] = '-9999px'; // Move element to the same position vertically
+
+  var yPosition = window.pageYOffset || document.documentElement.scrollTop;
+  fakeElement.style.top = "".concat(yPosition, "px");
+  fakeElement.setAttribute('readonly', '');
+  fakeElement.value = value;
+  return fakeElement;
+}
+;// CONCATENATED MODULE: ./src/actions/copy.js
+
+
+
+/**
+ * Create fake copy action wrapper using a fake element.
+ * @param {String} target
+ * @param {Object} options
+ * @return {String}
+ */
+
+var fakeCopyAction = function fakeCopyAction(value, options) {
+  var fakeElement = createFakeElement(value);
+  options.container.appendChild(fakeElement);
+  var selectedText = select_default()(fakeElement);
+  command('copy');
+  fakeElement.remove();
+  return selectedText;
+};
+/**
+ * Copy action wrapper.
+ * @param {String|HTMLElement} target
+ * @param {Object} options
+ * @return {String}
+ */
+
+
+var ClipboardActionCopy = function ClipboardActionCopy(target) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+    container: document.body
+  };
+  var selectedText = '';
+
+  if (typeof target === 'string') {
+    selectedText = fakeCopyAction(target, options);
+  } else if (target instanceof HTMLInputElement && !['text', 'search', 'url', 'tel', 'password'].includes(target === null || target === void 0 ? void 0 : target.type)) {
+    // If input type doesn't support `setSelectionRange`. Simulate it. https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement/setSelectionRange
+    selectedText = fakeCopyAction(target.value, options);
+  } else {
+    selectedText = select_default()(target);
+    command('copy');
+  }
+
+  return selectedText;
+};
+
+/* harmony default export */ var actions_copy = (ClipboardActionCopy);
+;// CONCATENATED MODULE: ./src/actions/default.js
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+
+
+/**
+ * Inner function which performs selection from either `text` or `target`
+ * properties and then executes copy or cut operations.
+ * @param {Object} options
+ */
+
+var ClipboardActionDefault = function ClipboardActionDefault() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  // Defines base properties passed from constructor.
+  var _options$action = options.action,
+      action = _options$action === void 0 ? 'copy' : _options$action,
+      container = options.container,
+      target = options.target,
+      text = options.text; // Sets the `action` to be performed which can be either 'copy' or 'cut'.
+
+  if (action !== 'copy' && action !== 'cut') {
+    throw new Error('Invalid "action" value, use either "copy" or "cut"');
+  } // Sets the `target` property using an element that will be have its content copied.
+
+
+  if (target !== undefined) {
+    if (target && _typeof(target) === 'object' && target.nodeType === 1) {
+      if (action === 'copy' && target.hasAttribute('disabled')) {
+        throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');
+      }
+
+      if (action === 'cut' && (target.hasAttribute('readonly') || target.hasAttribute('disabled'))) {
+        throw new Error('Invalid "target" attribute. You can\'t cut text from elements with "readonly" or "disabled" attributes');
+      }
+    } else {
+      throw new Error('Invalid "target" value, use a valid Element');
+    }
+  } // Define selection strategy based on `text` property.
+
+
+  if (text) {
+    return actions_copy(text, {
+      container: container
+    });
+  } // Defines which selection strategy based on `target` property.
+
+
+  if (target) {
+    return action === 'cut' ? actions_cut(target) : actions_copy(target, {
+      container: container
+    });
+  }
+};
+
+/* harmony default export */ var actions_default = (ClipboardActionDefault);
+;// CONCATENATED MODULE: ./src/clipboard.js
+function clipboard_typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { clipboard_typeof = function _typeof(obj) { return typeof obj; }; } else { clipboard_typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return clipboard_typeof(obj); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (clipboard_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+
+
+
+
+
+/**
+ * Helper function to retrieve attribute value.
+ * @param {String} suffix
+ * @param {Element} element
+ */
+
+function getAttributeValue(suffix, element) {
+  var attribute = "data-clipboard-".concat(suffix);
+
+  if (!element.hasAttribute(attribute)) {
+    return;
+  }
+
+  return element.getAttribute(attribute);
+}
+/**
+ * Base class which takes one or more elements, adds event listeners to them,
+ * and instantiates a new `ClipboardAction` on each click.
+ */
+
+
+var Clipboard = /*#__PURE__*/function (_Emitter) {
+  _inherits(Clipboard, _Emitter);
+
+  var _super = _createSuper(Clipboard);
+
+  /**
+   * @param {String|HTMLElement|HTMLCollection|NodeList} trigger
+   * @param {Object} options
+   */
+  function Clipboard(trigger, options) {
+    var _this;
+
+    _classCallCheck(this, Clipboard);
+
+    _this = _super.call(this);
+
+    _this.resolveOptions(options);
+
+    _this.listenClick(trigger);
+
+    return _this;
+  }
+  /**
+   * Defines if attributes would be resolved using internal setter functions
+   * or custom functions that were passed in the constructor.
+   * @param {Object} options
+   */
+
+
+  _createClass(Clipboard, [{
+    key: "resolveOptions",
+    value: function resolveOptions() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      this.action = typeof options.action === 'function' ? options.action : this.defaultAction;
+      this.target = typeof options.target === 'function' ? options.target : this.defaultTarget;
+      this.text = typeof options.text === 'function' ? options.text : this.defaultText;
+      this.container = clipboard_typeof(options.container) === 'object' ? options.container : document.body;
+    }
+    /**
+     * Adds a click event listener to the passed trigger.
+     * @param {String|HTMLElement|HTMLCollection|NodeList} trigger
+     */
+
+  }, {
+    key: "listenClick",
+    value: function listenClick(trigger) {
+      var _this2 = this;
+
+      this.listener = listen_default()(trigger, 'click', function (e) {
+        return _this2.onClick(e);
+      });
+    }
+    /**
+     * Defines a new `ClipboardAction` on each click event.
+     * @param {Event} e
+     */
+
+  }, {
+    key: "onClick",
+    value: function onClick(e) {
+      var trigger = e.delegateTarget || e.currentTarget;
+      var action = this.action(trigger) || 'copy';
+      var text = actions_default({
+        action: action,
+        container: this.container,
+        target: this.target(trigger),
+        text: this.text(trigger)
+      }); // Fires an event based on the copy operation result.
+
+      this.emit(text ? 'success' : 'error', {
+        action: action,
+        text: text,
+        trigger: trigger,
+        clearSelection: function clearSelection() {
+          if (trigger) {
+            trigger.focus();
+          }
+
+          window.getSelection().removeAllRanges();
+        }
+      });
+    }
+    /**
+     * Default `action` lookup function.
+     * @param {Element} trigger
+     */
+
+  }, {
+    key: "defaultAction",
+    value: function defaultAction(trigger) {
+      return getAttributeValue('action', trigger);
+    }
+    /**
+     * Default `target` lookup function.
+     * @param {Element} trigger
+     */
+
+  }, {
+    key: "defaultTarget",
+    value: function defaultTarget(trigger) {
+      var selector = getAttributeValue('target', trigger);
+
+      if (selector) {
+        return document.querySelector(selector);
+      }
+    }
+    /**
+     * Allow fire programmatically a copy action
+     * @param {String|HTMLElement} target
+     * @param {Object} options
+     * @returns Text copied.
+     */
+
+  }, {
+    key: "defaultText",
+
+    /**
+     * Default `text` lookup function.
+     * @param {Element} trigger
+     */
+    value: function defaultText(trigger) {
+      return getAttributeValue('text', trigger);
+    }
+    /**
+     * Destroy lifecycle.
+     */
+
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.listener.destroy();
+    }
+  }], [{
+    key: "copy",
+    value: function copy(target) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+        container: document.body
+      };
+      return actions_copy(target, options);
+    }
+    /**
+     * Allow fire programmatically a cut action
+     * @param {String|HTMLElement} target
+     * @returns Text cutted.
+     */
+
+  }, {
+    key: "cut",
+    value: function cut(target) {
+      return actions_cut(target);
+    }
+    /**
+     * Returns the support of the given action, or all actions if no action is
+     * given.
+     * @param {String} [action]
+     */
+
+  }, {
+    key: "isSupported",
+    value: function isSupported() {
+      var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['copy', 'cut'];
+      var actions = typeof action === 'string' ? [action] : action;
+      var support = !!document.queryCommandSupported;
+      actions.forEach(function (action) {
+        support = support && !!document.queryCommandSupported(action);
+      });
+      return support;
+    }
+  }]);
+
+  return Clipboard;
+}((tiny_emitter_default()));
+
+/* harmony default export */ var clipboard = (Clipboard);
+
+/***/ }),
+
+/***/ 828:
+/***/ (function(module) {
+
+var DOCUMENT_NODE_TYPE = 9;
+
+/**
+ * A polyfill for Element.matches()
+ */
+if (typeof Element !== 'undefined' && !Element.prototype.matches) {
+    var proto = Element.prototype;
+
+    proto.matches = proto.matchesSelector ||
+                    proto.mozMatchesSelector ||
+                    proto.msMatchesSelector ||
+                    proto.oMatchesSelector ||
+                    proto.webkitMatchesSelector;
+}
+
+/**
+ * Finds the closest parent that matches a selector.
+ *
+ * @param {Element} element
+ * @param {String} selector
+ * @return {Function}
+ */
+function closest (element, selector) {
+    while (element && element.nodeType !== DOCUMENT_NODE_TYPE) {
+        if (typeof element.matches === 'function' &&
+            element.matches(selector)) {
+          return element;
+        }
+        element = element.parentNode;
+    }
+}
+
+module.exports = closest;
+
+
+/***/ }),
+
+/***/ 438:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+var closest = __webpack_require__(828);
+
+/**
+ * Delegates event to a selector.
+ *
+ * @param {Element} element
+ * @param {String} selector
+ * @param {String} type
+ * @param {Function} callback
+ * @param {Boolean} useCapture
+ * @return {Object}
+ */
+function _delegate(element, selector, type, callback, useCapture) {
+    var listenerFn = listener.apply(this, arguments);
+
+    element.addEventListener(type, listenerFn, useCapture);
+
+    return {
+        destroy: function() {
+            element.removeEventListener(type, listenerFn, useCapture);
+        }
+    }
+}
+
+/**
+ * Delegates event to a selector.
+ *
+ * @param {Element|String|Array} [elements]
+ * @param {String} selector
+ * @param {String} type
+ * @param {Function} callback
+ * @param {Boolean} useCapture
+ * @return {Object}
+ */
+function delegate(elements, selector, type, callback, useCapture) {
+    // Handle the regular Element usage
+    if (typeof elements.addEventListener === 'function') {
+        return _delegate.apply(null, arguments);
+    }
+
+    // Handle Element-less usage, it defaults to global delegation
+    if (typeof type === 'function') {
+        // Use `document` as the first parameter, then apply arguments
+        // This is a short way to .unshift `arguments` without running into deoptimizations
+        return _delegate.bind(null, document).apply(null, arguments);
+    }
+
+    // Handle Selector-based usage
+    if (typeof elements === 'string') {
+        elements = document.querySelectorAll(elements);
+    }
+
+    // Handle Array-like based usage
+    return Array.prototype.map.call(elements, function (element) {
+        return _delegate(element, selector, type, callback, useCapture);
+    });
+}
+
+/**
+ * Finds closest match and invokes callback.
+ *
+ * @param {Element} element
+ * @param {String} selector
+ * @param {String} type
+ * @param {Function} callback
+ * @return {Function}
+ */
+function listener(element, selector, type, callback) {
+    return function(e) {
+        e.delegateTarget = closest(e.target, selector);
+
+        if (e.delegateTarget) {
+            callback.call(element, e);
+        }
+    }
+}
+
+module.exports = delegate;
+
+
+/***/ }),
+
+/***/ 879:
+/***/ (function(__unused_webpack_module, exports) {
+
+/**
+ * Check if argument is a HTML element.
+ *
+ * @param {Object} value
+ * @return {Boolean}
+ */
+exports.node = function(value) {
+    return value !== undefined
+        && value instanceof HTMLElement
+        && value.nodeType === 1;
+};
+
+/**
+ * Check if argument is a list of HTML elements.
+ *
+ * @param {Object} value
+ * @return {Boolean}
+ */
+exports.nodeList = function(value) {
+    var type = Object.prototype.toString.call(value);
+
+    return value !== undefined
+        && (type === '[object NodeList]' || type === '[object HTMLCollection]')
+        && ('length' in value)
+        && (value.length === 0 || exports.node(value[0]));
+};
+
+/**
+ * Check if argument is a string.
+ *
+ * @param {Object} value
+ * @return {Boolean}
+ */
+exports.string = function(value) {
+    return typeof value === 'string'
+        || value instanceof String;
+};
+
+/**
+ * Check if argument is a function.
+ *
+ * @param {Object} value
+ * @return {Boolean}
+ */
+exports.fn = function(value) {
+    var type = Object.prototype.toString.call(value);
+
+    return type === '[object Function]';
+};
+
+
+/***/ }),
+
+/***/ 370:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+var is = __webpack_require__(879);
+var delegate = __webpack_require__(438);
+
+/**
+ * Validates all params and calls the right
+ * listener function based on its target type.
+ *
+ * @param {String|HTMLElement|HTMLCollection|NodeList} target
+ * @param {String} type
+ * @param {Function} callback
+ * @return {Object}
+ */
+function listen(target, type, callback) {
+    if (!target && !type && !callback) {
+        throw new Error('Missing required arguments');
+    }
+
+    if (!is.string(type)) {
+        throw new TypeError('Second argument must be a String');
+    }
+
+    if (!is.fn(callback)) {
+        throw new TypeError('Third argument must be a Function');
+    }
+
+    if (is.node(target)) {
+        return listenNode(target, type, callback);
+    }
+    else if (is.nodeList(target)) {
+        return listenNodeList(target, type, callback);
+    }
+    else if (is.string(target)) {
+        return listenSelector(target, type, callback);
+    }
+    else {
+        throw new TypeError('First argument must be a String, HTMLElement, HTMLCollection, or NodeList');
+    }
+}
+
+/**
+ * Adds an event listener to a HTML element
+ * and returns a remove listener function.
+ *
+ * @param {HTMLElement} node
+ * @param {String} type
+ * @param {Function} callback
+ * @return {Object}
+ */
+function listenNode(node, type, callback) {
+    node.addEventListener(type, callback);
+
+    return {
+        destroy: function() {
+            node.removeEventListener(type, callback);
+        }
+    }
+}
+
+/**
+ * Add an event listener to a list of HTML elements
+ * and returns a remove listener function.
+ *
+ * @param {NodeList|HTMLCollection} nodeList
+ * @param {String} type
+ * @param {Function} callback
+ * @return {Object}
+ */
+function listenNodeList(nodeList, type, callback) {
+    Array.prototype.forEach.call(nodeList, function(node) {
+        node.addEventListener(type, callback);
+    });
+
+    return {
+        destroy: function() {
+            Array.prototype.forEach.call(nodeList, function(node) {
+                node.removeEventListener(type, callback);
+            });
+        }
+    }
+}
+
+/**
+ * Add an event listener to a selector
+ * and returns a remove listener function.
+ *
+ * @param {String} selector
+ * @param {String} type
+ * @param {Function} callback
+ * @return {Object}
+ */
+function listenSelector(selector, type, callback) {
+    return delegate(document.body, selector, type, callback);
+}
+
+module.exports = listen;
+
+
+/***/ }),
+
+/***/ 817:
+/***/ (function(module) {
+
+function select(element) {
+    var selectedText;
+
+    if (element.nodeName === 'SELECT') {
+        element.focus();
+
+        selectedText = element.value;
+    }
+    else if (element.nodeName === 'INPUT' || element.nodeName === 'TEXTAREA') {
+        var isReadOnly = element.hasAttribute('readonly');
+
+        if (!isReadOnly) {
+            element.setAttribute('readonly', '');
+        }
+
+        element.select();
+        element.setSelectionRange(0, element.value.length);
+
+        if (!isReadOnly) {
+            element.removeAttribute('readonly');
+        }
+
+        selectedText = element.value;
+    }
+    else {
+        if (element.hasAttribute('contenteditable')) {
+            element.focus();
+        }
+
+        var selection = window.getSelection();
+        var range = document.createRange();
+
+        range.selectNodeContents(element);
+        selection.removeAllRanges();
+        selection.addRange(range);
+
+        selectedText = selection.toString();
+    }
+
+    return selectedText;
+}
+
+module.exports = select;
+
+
+/***/ }),
+
+/***/ 279:
+/***/ (function(module) {
+
+function E () {
+  // Keep this empty so it's easier to inherit from
+  // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)
+}
+
+E.prototype = {
+  on: function (name, callback, ctx) {
+    var e = this.e || (this.e = {});
+
+    (e[name] || (e[name] = [])).push({
+      fn: callback,
+      ctx: ctx
+    });
+
+    return this;
+  },
+
+  once: function (name, callback, ctx) {
+    var self = this;
+    function listener () {
+      self.off(name, listener);
+      callback.apply(ctx, arguments);
+    };
+
+    listener._ = callback
+    return this.on(name, listener, ctx);
+  },
+
+  emit: function (name) {
+    var data = [].slice.call(arguments, 1);
+    var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
+    var i = 0;
+    var len = evtArr.length;
+
+    for (i; i < len; i++) {
+      evtArr[i].fn.apply(evtArr[i].ctx, data);
+    }
+
+    return this;
+  },
+
+  off: function (name, callback) {
+    var e = this.e || (this.e = {});
+    var evts = e[name];
+    var liveEvents = [];
+
+    if (evts && callback) {
+      for (var i = 0, len = evts.length; i < len; i++) {
+        if (evts[i].fn !== callback && evts[i].fn._ !== callback)
+          liveEvents.push(evts[i]);
+      }
+    }
+
+    // Remove event from queue to prevent memory leak
+    // Suggested by https://github.com/lazd
+    // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910
+
+    (liveEvents.length)
+      ? e[name] = liveEvents
+      : delete e[name];
+
+    return this;
+  }
+};
+
+module.exports = E;
+module.exports.TinyEmitter = E;
+
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		if(__webpack_module_cache__[moduleId]) {
+/******/ 			return __webpack_module_cache__[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/compat get default export */
+/******/ 	!function() {
+/******/ 		// getDefaultExport function for compatibility with non-harmony modules
+/******/ 		__webpack_require__.n = function(module) {
+/******/ 			var getter = module && module.__esModule ?
+/******/ 				function() { return module['default']; } :
+/******/ 				function() { return module; };
+/******/ 			__webpack_require__.d(getter, { a: getter });
+/******/ 			return getter;
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	!function() {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = function(exports, definition) {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	!function() {
+/******/ 		__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
+/******/ 	}();
+/******/ 	
+/************************************************************************/
+/******/ 	// module exports must be returned from runtime so entry inlining is disabled
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(686);
+/******/ })()
+.default;
+});

assets/common.css

@@ -0,0 +1,521 @@
+/*.main-header{*/
+/*    background-color: #343339;*/
+/*    border-bottom:1px solid #d9d9d9;*/
+/*    color: #fff;*/
+/*}*/
+/*.main-header .main-header-menu .webix_scroll_cont{*/
+/*    height: 100%;*/
+/*}*/
+/*.main-header .webix_menu-x .webix_list_item{*/
+/*    background: none;*/
+/*}*/
+/*.wotu-ui .main-header .webix_el_button.webix_secondary .webix_button{*/
+/*    color:#fff*/
+/*}*/
+/**/
+/* studio */
+.home {
+    padding: 0 0 0 16px;
+}
+
+.home .title {
+    width: 30%;
+    text-align: right;
+    color: #000000d9;
+    font-size: 14px;
+    line-height: 1.6;
+    display: inline-block;
+}
+
+.home .subtitle {
+    color: #5468ff;
+    font-size: 24px;
+    line-height: 1.8;
+    text-align: right;
+    font-weight: bold;
+    width: 30%;
+    display: inline-block;
+}
+
+/*页面头部*/
+
+.main-header {
+    box-shadow: 0px 5px 5px #e4e4e4;
+}
+
+.main-header .header-menu {
+    border: none;
+    background: none;
+}
+
+.main-header .header-menu .x-btn-inner-default-small {
+    color: #000000;
+}
+
+.main-header .header-menu .x-btn-wrap-default-small.x-btn-arrow-right:after {
+    color: #000000;
+}
+
+.main-header .header-menu.x-btn.x-btn-menu-active.x-btn-default-small, .main-header .header-menu.x-btn.x-btn-pressed.x-btn-default-small {
+    background: none;
+    border: none;
+}
+
+.x-keyboard-mode .main-header .x-btn-focus.x-btn-default-small {
+    background: none;
+    box-shadow: none;
+}
+
+/*页面头部样式*/
+.main-header > .x-panel-bodyWrap > .x-box-layout-ct {
+    border-left: none;
+}
+
+.x-menu .x-menu-icon-separator-default {
+    border: none
+}
+
+.x-menu .x-menu-item-text-default.x-menu-item-indent {
+    margin-left: 30px;
+}
+
+.x-tree-view {
+    border-top: 1px solid #d0d0d0;
+}
+
+.dataview-horizontal > div {
+    float: left;
+    padding: 0 20px;
+}
+
+.dataview-horizontal > div > div:last-child {
+    border: black solid 1px;
+}
+
+/*表格样式修改*/
+.dataview-horizontal-table > div {
+    float: left;
+    padding: 10px 10px;
+    width: 30%;
+}
+
+.dataview-horizontal-table > div > table {
+    border: black solid 1px;
+    width: 100%;
+    font-size: large;
+}
+
+.dataview-horizontal-table td {
+    padding: 10px 0;
+}
+
+.dataview-horizontal-table button {
+    font-size: larger;
+}
+
+.x-panel-body-default {
+    border-left: none;
+    border-right: none;
+}
+
+.x-docked-noborder-left {
+    border-left-width: 1px !important;
+}
+
+.x-panel-body-default {
+    border-top: none;
+    border-bottom: none;
+}
+
+.x-autocontainer-innerCt > .x-toolbar {
+    border-left: none;
+}
+
+.x-autocontainer-innerCt .x-autocontainer-innerCt {
+    border: none;
+}
+
+.x-fieldset-default {
+    border: 1px solid #dfdfdf !important;
+    padding: 5px 14px 10px 14px;
+}
+
+.x-fieldset .x-autocontainer-innerCt {
+    border-left: none;
+}
+
+.x-toolbar-docked-top {
+    border-left: 1px solid #d0d0d0;
+    border-top: none;
+}
+
+.x-panel-bodyWrap > .x-box-layout-ct {
+    border-left: 1px solid #d0d0d0;
+    border-right: none;
+}
+
+.x-tab-bar-body.x-box-layout-ct {
+    border-left: none;
+}
+
+.x-grid-header-ct-default .x-box-inner {
+    border-top: 1px solid #d0d0d0;
+    border-bottom: 1px solid #d0d0d0;
+}
+
+.x-column-header-sort-DESC .x-column-header-text, .x-column-header-sort-ASC .x-column-header-text {
+    overflow: hidden;
+}
+
+.x-box-inner .x-autocontainer-innerCt {
+    border-left: none;
+}
+
+.x-grid-no-row-lines {
+    border-left: 1px solid #d0d0d0;
+}
+
+.x-tree-checkbox {
+    color: #9cb9b2;
+}
+
+.secondRowBigFont tr td:nth-child(2) .x-grid-cell-inner {
+    font-size: 16px;
+}
+
+/*弹出框样式修改*/
+body .x-mask {
+    background-color: rgba(0, 0, 0, 0.5)
+}
+
+.wotu-ui .x-window-default,
+.x-toolbar-footer {
+    background-color: #fff;
+    width: 600px;
+    border-radius: 4px;
+    border: 1px solid #fff;
+    vertical-align: middle;
+    margin-bottom: 5px;
+}
+
+.wotu-ui .x-window-default, .wotu-ui .x-window-header-default {
+    border-bottom: 1px solid #bbb;
+}
+
+.wotu-ui .x-window-header-default .x-tool-img {
+    color: #fff;
+}
+
+/*.wotu-ui .x-window .x-window-header-default .x-tool-img {*/
+/*    background: #fff;*/
+/*}*/
+
+.x-window-header-title-default > .x-title-text-default {
+    padding-left: 0;
+    margin-bottom: 0;
+    font-size: 18px;
+    line-height: 1;
+    color: #fff;
+}
+
+.x-window-header.x-header {
+    color: #000;
+}
+
+.x-window {
+    background-color: ragb(0, 0, 0, 0.5);
+}
+
+.x-window .x-window-text {
+    line-height: 20px;
+}
+
+.x-window .x-tool-tool-el.x-tool-img.x-tool-close {
+    left: 552px;
+}
+
+.x-window .x-btn-inner-default-small {
+    color: #fff;
+    font-size: 12px;
+    background-color: #5fa2dd;
+    border-color: #5fa2dd;
+    border-radius: 3px;
+}
+
+.x-window .x-btn:focus {
+    box-shadow: none !important;
+}
+
+.x-window .x-btn-default-small {
+    border: none;
+    background-color: #fff;
+}
+
+.x-panel-body-default {
+    /*border: none;*/
+    font-size: 14px;
+    line-height: 20px;
+}
+
+.x-window .x-autocontainer-innerCt {
+    padding: 5px 0;
+}
+
+.x-window .x-autocontainer-innerCt .x-autocontainer-innerCt {
+    padding-left: 0;
+}
+
+.x-window .x-btn-default-small {
+    color: #fff;
+    border-radius: 3px;
+    background-color: #5fa2dd;
+    border-color: #5fa2dd;
+}
+
+.x-window .x-btn-default-small:hover,
+.x-window .x-btn-default-small:hover .x-btn-inner {
+    border-color: #518bbd;
+    background-image: none;
+    background-color: #5795cb;
+}
+
+.x-window .x-btn-default-small:active .x-btn-inner {
+    border-color: #1960af;
+    background-image: none;
+    background-color: #1960af;
+}
+
+.x-window .x-component.x-window-text.x-box-item.x-component-default {
+    font-size: 14px;
+    margin-bottom: 5px;
+}
+
+.x-window .x-panel-bodyWrap > .x-box-layout-ct {
+    border-left: none;
+}
+
+.x-tip .x-autocontainer-innerCt {
+    border-left: none;
+}
+
+.x-docked .x-btn-icon-el-default-small {
+    color: #fff;
+}
+
+.viewer-container.viewer-backdrop.viewer-fixed {
+    z-index: 19000 !important;
+}
+
+
+.x-mask-msg {
+    width: 92px;
+    height: 82px;
+    text-align: center;
+    background-color: rgba(0, 0, 0, .8);
+    border-radius: 4px;
+
+}
+
+.x-mask-loading.x-mask-msg-inner,
+.x-mask-msg .x-mask-msg-inner {
+    margin-top: 8px;
+}
+
+.x-mask-msg-inner .x-mask-msg-text {
+    color: #fff;
+    padding-top: 30px;
+}
+
+.yvan-msg.yvan-anim {
+    border-radius: 4px;
+}
+
+/*表格样式调整*/
+.x-grid-header-ct.x-docked.x-grid-header-ct-default {
+    box-shadow: 0 1px 4px 0 rgba(0, 0, 0, .2);
+    border-left: none;
+}
+
+.x-column-header-sort-ASC .x-column-header-text-inner:after, .x-column-header-sort-DESC .x-column-header-text-inner:after {
+    position: absolute;
+    top: 50%;
+    right: 0px;
+    transform: translateY(-50%);
+}
+
+.x-column-header-text {
+    text-align: center;
+}
+
+.x-column-header-align-right .x-column-header-text {
+    margin-right: 0;
+}
+
+.x-column-header-inner {
+    padding: 7px;
+}
+
+.x-grid-cell-inner .progress-danger {
+    background-color: #D9534F;
+}
+
+.x-grid-cell-inner .progress-warning {
+    background-color: #F0AD4E;
+}
+
+.x-grid-cell-inner .progress-success {
+    background-color: #5CB85C;
+}
+
+.x-grid-cell-inner .area-tag {
+    width: 100%;
+    height: 32px;
+    border: none;
+    background-color: #16993c;
+    border: 1px solid #16993c;
+    /*padding: 7px 0 6px;*/
+    text-align: center;
+    text-overflow: ellipsis;
+    overflow: hidden;
+    white-space: nowrap;
+}
+
+.td-btn .x-grid-cell-inner {
+    padding: 0 10px 0;
+}
+
+.td-percent .x-grid-cell-inner {
+    padding: 4px 10px;
+}
+
+.x-grid-cell-inner .area-tag:hover {
+    border-color: #40b061;
+    background-image: none;
+    background-color: #40b061;
+}
+
+.x-grid-cell-inner .area-tag:active {
+    -webkit-box-shadow: #ced8e1 0 1px 0px 0 inset, #ced8e1 0 -1px 0px 0 inset, #ced8e1 -1px 0 0px 0 inset, #ced8e1 1px 0 0px 0 inset;
+    -moz-box-shadow: #ced8e1 0 1px 0px 0 inset, #ced8e1 0 -1px 0px 0 inset, #ced8e1 -1px 0 0px 0 inset, #ced8e1 1px 0 0px 0 inset;
+    box-shadow: #ced8e1 0 1px 0px 0 inset, #ced8e1 0 -1px 0px 0 inset, #ced8e1 -1px 0 0px 0 inset, #ced8e1 1px 0 0px 0 inset;
+    border-color: #42719a;
+    background-image: none;
+    background-color: #209a43;
+}
+
+.wotu-ui .x-item-disabled.x-grid-td .x-grid-checkcolumn,
+.wotu-ui .x-item-disabled.x-grid-td .x-grid-checkcolumn {
+    opacity: 0.5;
+}
+
+.x-tree-checkbox,
+.x-grid-hd-checker-on .x-column-header-checkbox:after,
+.x-grid-checkcolumn-checked:after {
+    color: #9cb9b2;
+}
+
+/*工具栏样式修改*/
+.x-toolbar-default.x-docked-bottom.x-toolbar-docked-bottom {
+    box-shadow: 0 1px 4px 0 rgba(0, 0, 0, .6);
+    border-bottom: none;
+}
+
+.x-toolbar.x-toolbar-docked-bottom input {
+    padding: 0;
+}
+
+/*详情样式调整*/
+.allowScroll .x-panel-body.x-panel-body-default {
+    overflow: scroll;
+    padding: 8px;
+}
+
+.allowScroll .x-panel-body.x-panel-body-default pre {
+    margin: 0;
+}
+
+/*图标字体样式调整*/
+.x-panel.main-header .x-btn-icon-el-default-small {
+    color: #404040;
+}
+
+.x-form-item-default.x-item-disabled {
+    opacity: 1;
+}
+
+/*特殊样式*/
+.large-black .x-form-item-label-text {
+    font-size: 18px !important;
+    font-weight: bold !important;
+    color: black !important;
+}
+
+.large-black input.x-form-field {
+    font-size: 18px !important;
+    color: black !important;
+    font-weight: bold !important;
+}
+
+.large-green .x-form-item-label-text {
+    font-size: 18px !important;
+    font-weight: bold !important;
+    color: green !important;
+}
+
+.large-green input.x-form-field {
+    font-size: 18px !important;
+    color: green !important;
+    font-weight: bold !important;
+}
+
+.large-red .x-form-item-label-text {
+    font-size: 18px !important;
+    font-weight: bold !important;
+    color: red !important;
+}
+
+.large-red input.x-form-field {
+    font-size: 18px !important;
+    color: red !important;
+    font-weight: bold !important;
+}
+
+/* 皮肤
+.wotu-ui .x-panel-header.x-panel-header-default {
+    background: #209a43;
+}
+
+.wotu-ui .x-tab-bar.x-tab-bar-default {
+    background: #209a43;
+}
+
+.wotu-ui .x-window-header.x-window-default,
+.wotu-ui .x-window-header.x-window-header-default {
+    border-color: #209a43;
+}
+
+.wotu-ui .x-window-header.x-window-header-default-top {
+    background: #209a43;
+}
+
+.wotu-ui .x-window.x-window-default,
+.wotu-ui .x-window.x-window-header-default {
+    border-color: #209a43;
+}
+
+.wotu-ui .x-window-header-default .x-tool-tool-el.x-tool-img {
+    background: #209a43;
+}
+
+.x-window.x-layer.x-window-default {
+    border-color: #209a43 !important;
+}
+*/
+
+/*--grid里面的拖拽-*/
+.x-grid-body .x-splitter{
+    display: none;
+}
+.x-menu-item-link{
+    min-height: 30px;
+}

assets/dark.css

@@ -0,0 +1,602 @@
+.main-header > .x-panel-bodyWrap > .x-panel-body > .x-box-inner{
+ background: #000
+}
+.main-header > .x-panel-bodyWrap > .x-panel-body > .x-box-inner > .x-box-target > .yvan_design > .x-panel-bodyWrap > .x-panel-body{
+ background: #000
+}
+.main-header .header-menu .x-btn-inner-default-small{
+ color:#fff;
+ font-size: 13px;
+}
+.x-panel.main-header .x-btn-icon-el-default-small{
+ color: #cdc9a5;
+}
+.wotu-ui .main-tree-left .x-panel-header-default {
+ background: #212121;
+ border-bottom:1px solid #000;
+ box-sizing: content-box;
+}
+.x-autowidth-table .x-grid-item{
+ background: #212121;
+}
+.wotu-ui .main-tree-left .x-panel-bodyWrap > .x-box-layout-ct{
+ background: #212121;
+}
+.wotu-ui .main-tree-left .x-tree-view{
+ background: #212121;
+}
+.wotu-ui .main-tree-left .x-panel-bodyWrap > .x-box-layout-ct{
+ border-left-color:#212121;
+ border-top: 1px solid #313030;
+}
+.wotu-ui .main-tree-left .x-tree-view{
+ border-top-color:#212121;
+}
+.wotu-ui .main-tree-left .x-grid-no-row-lines{
+ border-left-color:#212121;
+}
+.wotu-ui .main-tree-left .x-grid-row[aria-selected="true"]{
+ background-color: #5a5a5a;
+}
+.x-form-text-default{
+ background: #000;
+}
+.main-tree-left + .x-splitter{
+ background: #000;
+}
+/*滚公条*/
+*::-webkit-scrollbar{
+ width:9px;
+ height:12px;
+}
+*::-webkit-scrollbar-button{
+ width:0px;
+ height:0px;
+}
+*::-webkit-scrollbar-track{
+ background: #212121;
+}
+/*滚轴的颜色*/
+*::-webkit-scrollbar-thumb{
+ background:#555758;
+}
+*::-webkit-scrollbar-track,*::-webkit-scrollbar-thumb{
+ border-radius:3px;
+}
+*::-webkit-scrollbar-corner,*::-webkit-scrollbar-button{
+ background:#3f4244;
+}
+.x-grid-item-selected{
+ color:#fff
+}
+.wotu-ui .main-tree-left .x-tree-icon-leaf,.wotu-ui .main-tree-left .x-tree-icon-parent-expanded{
+ color:#fff
+}
+.wotu-ui .main-tree-left .x-grid-item{
+ color:#fff;
+ font-weight: 400;
+}
+.wotu-ui .main-tree-left  .x-grid-row[aria-selected="true"]{
+ color:#fff
+}
+.wotu-ui .main-tree-left .x-tree-icon-parent{
+ color:#fff
+}
+.x-keyboard-mode .main-tree-left .x-grid-row[aria-selected="true"] .x-grid-item-focused{
+ color: #fff;
+}
+.wotu-ui .main-tree-left .x-grid-tree-node-expanded .x-tree-elbow-plus, .wotu-ui .main-tree-left .x-grid-tree-node-expanded .x-tree-elbow-end-plus{
+ color: #fff;
+}
+.wotu-ui .main-tree-left .x-tree-elbow-plus, .wotu-ui .main-tree-left .x-tree-elbow-end-plus, .wotu-ui .main-tree-left .x-tree-icon-parent{
+ color:#fff
+}
+.x-unselectable{
+ /*cursor: pointer;*/
+}
+.x-splitter-vertical{
+ cursor: col-resize;
+}
+.main-content > .x-panel-bodyWrap{
+ background: #212121;
+}
+.wotu-ui .main-content .x-tab-bar-plain.x-tab-bar .x-tab.x-tab-active.x-tab-default {
+ background: #434343;
+}
+.wotu-ui .main-content .x-tab.x-tab-active.x-tab-default .x-tab-inner-default {
+ color: #ffc600;
+}
+.wotu-ui .main-content >.x-panel-bodyWrap .x-tab-bar-plain.x-tab-bar .x-tab.x-tab-default{
+ border:none;
+ background: #222;
+}
+.wotu-ui .main-content >.x-panel-bodyWrap .x-tab-bar-plain.x-tab-bar .x-tab.x-tab-active.x-tab-default{
+ border:none;
+ background: #333;
+}
+.x-tab-bar-plain .x-tab-inner-default{
+ color: #c8c8c8;
+}
+.x-tab-bar-plain .x-tab-over.x-tab-default .x-tab-inner-default{
+ color: #ffc600;
+}
+.wotu-ui.x-border-layout-ct{
+ background: #212121;
+}
+.wotu-ui .main-content div.x-border-layout-ct{
+  background: #212121;
+}
+.wotu-ui .main-content .x-panel-bodyWrap > .x-box-layout-ct{
+ background: #333;
+}
+/*.main-content .x-toolbar{*/
+/* position: relative;*/
+/*}*/
+/*.main-content .x-toolbar:after{*/
+/* position: absolute;*/
+/* width: 100%;*/
+/* height: 1px;*/
+/* background: #fff;*/
+/* content: '';*/
+/* bottom:1px;*/
+/* left:0;*/
+/*}*/
+.main-content .x-panel:not(.x-grid-locked)>.x-panel-bodyWrap>.x-toolbar{
+ position: relative;
+}
+.main-content .x-panel:not(.x-grid-locked)>.x-panel-bodyWrap>.x-toolbar:after{
+  position: absolute;
+  width: 100%;
+  height: 1px;
+  background: #000;
+  content: '';
+  bottom:1px;
+  left:0;
+}
+.wotu-ui .x-column-header-inner{
+ background: #333;
+ color: #ffff;
+}
+.wotu-ui .x-column-header{
+ border-color:#505050;
+}
+.x-grid-scrollbar-clipper > .x-grid-view, .x-grid-scrollbar-clipper > .x-tree-view {
+ background-color: #333;
+}
+.x-grid-item{
+ background-color: #333;
+ color: #fff;
+}
+.wotu-ui .x-grid-header-ct-default .x-box-inner {
+ border-top: 1px solid #000000;
+ border-bottom: 1px solid #505050;
+}
+.wotu-ui .x-docked-noborder-left{
+ border:none
+}
+.wotu-ui .x-panel-bodyWrap > .x-box-layout-ct{
+ border:none;
+ background: #333;
+}
+.x-tree-view{
+ background: #333;
+ border-top:0
+}
+.x-grid-no-row-lines{
+ border:none
+}
+.x-toolbar{
+ border-bottom:1px solid #000;
+}
+.wotu-ui .x-grid-locked-split .x-grid-inner-normal{
+ border-color:#505050;
+}
+.wotu-ui .x-grid-with-col-lines .x-grid-cell{
+ border-color:#505050;
+
+}
+.wotu-ui .x-grid-row .x-grid-cell-selected{
+ background-color: #bfb79d;
+ color: #fff;
+}
+.wotu-ui .x-grid-with-row-lines .x-grid-item{
+ border-color: #505050;
+}
+.wotu-ui .x-grid-width-row-lines .x-grid-item-selected + .x-grid-item{
+ border:none;
+ background:#000;
+}
+.main-content .x-grid-item-over{
+ background: #000;
+}
+.wotu-ui .x-grid-width-row-lines .x-grid-item.x-grid-item-over{
+ border-color: #505050;
+ background: #000;
+}
+.wotu-ui .x-grid-row[aria-selected="true"],
+.wotu-ui .x-grid-row.x-grid-record-red[aria-selected="true"],
+.wotu-ui .x-grid-row.x-grid-record-bg-green[aria-selected="true"],
+.wotu-ui .x-grid-row.x-grid-record-bg-red[aria-selected="true"],
+.wotu-ui .x-grid-row.x-grid-record-bg-yellow[aria-selected="true"],
+.wotu-ui .x-grid-row.x-grid-record-bg-purple[aria-selected="true"],
+.wotu-ui .x-grid-row.x-grid-record-bg-blue[aria-selected="true"]{
+ background-color: #7f7f7f;
+ color: #fff;
+}
+.x-keyboard-mode .x-grid-row[aria-selected="true"] .x-grid-item-focused{
+ color: #fff;
+}
+.x-keyboard-mode .x-grid-cell-inner {
+ border:none
+}
+.x-grid-item-alt{
+ background: #444;
+}
+.x-tree-view.x-tree-view-default .x-grid-cell-inner{
+ cursor: pointer;
+}
+.x-grid-scroll-body{
+ background: #333;
+}
+.x-grid-empty{
+ background: #333;
+ color:#fff
+}
+.x-keyboard-mode .x-grid-item-focused{
+ color: #fff;
+}
+.x-column-header-trigger{
+ background-color: #000000;
+ border-left: 1px solid #3d3d3d;
+}
+.x-column-header-open .x-column-header-trigger{
+ background: #cdc9a5;
+ color: #fff;
+}
+.x-grid-scrollbar-visible{
+ background: #333;
+}
+.x-grid-cell-row-numberer {
+ background-color: #333;
+}
+.x-grid-inner-locked{
+ border-right-color: #505050;
+}
+.x-grid-scrollbar-clipper-locked{
+ border-color: #505050
+}
+.x-grid-cell-inner-row-numberer.x-grid-cell-inner{
+ color: #fff;
+}
+.x-grid-scroll-container {
+ background-color: #222;
+}
+.x-grid-scrollbar-clipper-locked, .x-grid-scrollbar-locked{
+ border-color: #4f5050;
+}
+/*-------------------*/
+.wotu-ui .x-panel-body-default{
+ background: #333;
+}
+
+.x-collapse-el{
+ background-color: #404040;
+ color: #989898
+}
+.wotu-ui .x-tree-checkbox,.wotu-ui .x-grid-hd-checker-on .x-column-header-checkbox:after,.wotu-ui .x-grid-checkcolumn-checked:after {
+ color: #d5ceb4;
+}
+.wotu-ui .main-content .x-tree-elbow-plus, .wotu-ui .main-content .x-tree-elbow-end-plus, .wotu-ui .main-content .x-tree-icon-parent {
+ color: #bfbfbf
+}
+.wotu-ui .main-content .x-grid-tree-node-expanded .x-tree-elbow-plus, .wotu-ui .main-content .x-grid-tree-node-expanded .x-tree-elbow-end-plus{
+ color: #bfbfbf
+}
+.wotu-ui .main-content .x-tree-icon-parent-expanded, .wotu-ui .main-content .x-tree-icon-leaf{
+ color: #bfbfbf
+}
+/*按钮*/
+.grid-bbar .x-btn-default-toolbar-small{
+ background: #333;
+ border: none;
+}
+.grid-bbar.x-toolbar-default.x-docked-bottom.x-toolbar-docked-bottom{
+ box-shadow: 0 1px 4px 0 rgba(190,190,190,.6);
+}
+.grid-bbar .x-btn-icon-el-default-toolbar-small{
+ color: #d3d3d3;
+}
+.grid-bbar .x-toolbar-text-default{
+ color: #fff;
+}
+.x-toolbar-default .x-toolbar-separator-horizontal{
+ border-left-color: #5e5e5e;
+}
+.x-btn.x-btn-disabled.x-btn-default-toolbar-small{
+ background-color: #7f7f7f;
+}
+.x-btn.x-btn-disabled .x-btn-inner-default-toolbar-small,.x-btn.x-btn-disabled .x-btn-icon-el-default-toolbar-small{
+ color: #cbcbcb;
+}
+/*-form-*/
+.wotu-ui .x-form-trigger-wrap-default{
+ border-color: #645f5f;
+}
+input::-webkit-input-placeholder {  /* WebKit browsers*/
+ color: #fff;
+ font-size: 14px;
+ font-weight: 400;
+}
+input:-moz-input-placeholder {   /* Mozilla Firefox 4 to 18*/
+ color: #fff;
+ font-size: 14px;
+ font-weight: 400;
+}
+input:-ms-input-placeholder { /* Internet Explorer 10+  9b9b99*/
+ color: #fff;
+ font-weight: 400;
+}
+.x-form-text-default{
+ color: #fff;
+}
+.x-form-trigger-default{
+ background: #000;
+ color: #ffffff;
+}
+.wotu-ui li.x-boundlist-selected{
+ background: #f4c521;
+ border-color: #f4c521;
+}
+.wotu-ui .x-boundlist-item.x-boundlist-item-over{
+ background: #f4c521;
+}
+.wotu-ui .x-boundlist-item {
+ background: #3e3e3e;
+ color: #fff;
+}
+.x-form-item-label-default{
+ color: #fff;
+ font-weight: 400;
+}
+.x-btn-default-toolbar-small{
+ background-color: #767676;
+ border-color: #767676;
+}
+.x-btn-default-toolbar-small .x-btn-inner-default-toolbar-small{
+ color: #fff;
+}
+.x-btn-default-toolbar-small .x-btn-icon-el-default-toolbar-small{
+ color: #fff;
+}
+.x-btn-over.x-btn-default-toolbar-small{
+ border-color: #f4c521;
+ background-image: none;
+ background-color: #f4c521;
+}
+.x-keyboard-mode .x-btn-focus.x-btn-default-toolbar-small{
+ background-color: #767676;
+ border-color: #767676;
+ color: #fff;
+}
+.x-toolbar-default .x-box-menu-after{
+ background: none;
+ border: none;
+}
+.x-fieldset.x-fieldset-default{
+ background: #333;
+ border: 1px solid #504f4f !important;
+}
+.x-fieldset-header-default > .x-fieldset-header-text{
+ color:#fff
+}
+.x-form-cb-label-default.x-form-cb-label-after{
+ color: #fff;
+}
+/*searchbox*/
+.x-boundlist>.x-panel>.x-panel-header{
+ background: #212121;
+}
+.x-boundlist .x-toolbar{
+ background: #212121;
+}
+.x-boundlist .x-toolbar-default{
+ background-color: #333;
+}
+.x-boundlist .x-grid-scroll-container{
+ background-color: #333;
+}
+.x-boundlist > .x-panel-default{
+ border: 1px solid #6a6868;
+}
+.x-css-shadow{
+ box-shadow: rgb(16 16 16) 0px 0px 102px!important;
+}
+/*-window-*/
+.wotu-ui .x-window.x-window-default, .wotu-ui .x-window.x-window-header-default {
+ border-color: #6a6868;
+}
+.wotu-ui .x-window .x-window-header-default-top{
+ background: #212121;
+ border:none;
+ border-bottom: 1px solid #313131;
+}
+.x-window-body-default{
+ background: #333;
+}
+.wotu-ui .x-window.x-window-default{
+ background: #333;
+}
+.x-window .x-window-bodyWrap .x-toolbar-footer{
+ background-color: #333;
+ padding: 10px 0 6px 6px;
+ border:none;
+ border-top:1px solid #212121;
+ border-radius: 0;
+}
+.wotu-ui .x-window.x-toolbar-footer{
+ background-color: #333;
+}
+.x-window-bodyWrap .x-toolbar{
+ border-color: #333;
+}
+.wotu-ui .x-window .x-panel-bodyWrap > .x-box-layout-ct{
+ background: #333;
+}
+.wotu-ui .x-window .x-panel-body-default{
+ background-color: #333;
+}
+.wotu-ui .x-window .x-window-header-default .x-tool-img{
+ background: #212121;
+}
+.wotu-ui .x-window .x-btn-default-small,.wotu-ui .x-window .x-btn-inner-default-small{
+ background-color: #b79f4b;
+ border-color: #b79f4b;
+}
+.wotu-ui .x-window .x-btn-default-small:hover,.wotu-ui .x-window .x-btn-default-small:hover .x-btn-inner{
+ background: #af9641;
+}
+.x-window-body>.x-panel>.x-panel-bodyWrap>.x-toolbar{
+ position: relative;
+}
+.x-window-body>.x-panel>.x-panel-bodyWrap>.x-toolbar:after{
+ position: absolute;
+ content: '';
+ width: 100%;
+ height: 1px;
+ left: 0;
+ bottom:0;
+ background: #000;
+}
+.wotu-ui .x-window .x-splitter-vertical{
+ background: #212121;
+}
+.x-box-scroller-body-vertical{
+ background: #333;
+}
+.x-menu-default{
+ border-color:#6a6868;
+}
+.x-menu-item-icon-default{
+ color: #fff;
+}
+.x-menu-item-text-default{
+ color: #fff;
+}
+.wotu-ui .x-menu-item.x-menu-item-default.x-menu-item-focus, .wotu-ui .x-menu-item.x-menu-item-default.x-menu-item-active{
+ background: #f4c521;
+}
+.x-menu-item-default.x-menu-item-separator{
+ border-color: #4a4848;
+}
+.wotu-ui .x-header.x-panel-header-default{
+ background: #333;
+}
+.wotu-ui .x-boundlist .x-header.x-panel-header-default{
+ background: #212121;
+}
+.wotu-ui .x-message-box .x-window-body{
+ background-color: #333;
+}
+.x-window-body-default{
+ color: #fff;
+}
+.x-menu-body-default{
+ background: #333;
+}
+.wotu-ui .x-tab-bar.x-tab-bar-default{
+ background: #212121;
+}
+.x-keyboard-mode .x-tab-bar-plain .x-tab-focus.x-tab-over.x-tab-default .x-tab-inner-default{
+ color:#f4c521
+}
+.yvan-msg{
+ background-color: rgba(0, 0, 0, .7);
+ font-weight: 400;
+}
+.x-tab.x-tab-active.x-tab-default{
+ background-color: #767676;
+}
+.x-keyboard-mode .x-tab-focus.x-tab-active.x-tab-default{
+ background-color: #767676;
+}
+/*日期*/
+.x-datepicker{
+ background-color: #333;
+ border-color: #7d7b7b;
+}
+.x-datepicker-header{
+ background-color: #333;
+}
+.x-datepicker-header .x-datepicker-month{
+ border-bottom: 1px solid #5f5d5d;
+}
+.x-datepicker-arrow{
+ background: #333;
+ color:#fff
+}
+.x-datepicker-column-header{
+ background: #333;
+ color: #fff;
+}
+.x-datepicker-footer, .x-monthpicker-buttons{
+ background-color: #333;
+}
+.wotu-ui .x-datepicker .x-datepicker-selected div.x-datepicker-date {
+ background: #f4c521;
+}
+.wotu-ui .x-datepicker .x-datepicker-footer .x-btn-default-small{
+ background: #767676;
+ border-color: #767676;
+}
+.wotu-ui .x-datepicker .x-datepicker-footer .x-btn-default-small:hover{
+ background: #f4c521;
+ border-color: #efc01a;
+}
+.x-datepicker-prevday .x-datepicker-date, .x-datepicker-nextday .x-datepicker-date{
+ color: #666464;
+}
+.x-datepicker-date{
+ color: #fff;
+}
+.x-datepicker-month .x-btn-inner {
+ color: #ffffff;
+}
+div.x-datepicker-date:hover {
+ background-color: #dcce9b;
+}
+.x-datepicker-month .x-btn-over{
+ background: #444;
+}
+.wotu-ui .x-datepicker .x-btn.x-btn-pressed.x-btn-default-small{
+ background: #444;
+}
+.x-datepicker .x-monthpicker{
+ background: #333;
+}
+.x-datepicker .x-monthpicker-item-inner{
+ color: #fff;
+}
+.x-monthpicker-item a.x-monthpicker-selected{
+ background: #f4c521;
+}
+a.x-monthpicker-item-inner:hover{
+ background-color: #dcce9b;
+}
+.x-monthpicker-yearnav-button{
+ background: #444;
+ color: #fff;
+}
+.x-monthpicker-buttons .x-btn-default-small{
+ background: #767676;
+ border-color: #767676;
+}
+.x-monthpicker-buttons .x-btn-default-small:hover{
+ background: #f4c521;
+ border-color: #efc01a;
+}
+.x-monthpicker-months{
+ border-color:#7d7b7b
+}
+.x-boundlist{
+ border-color:#7d7b7b
+}

assets/jquery/jquery.cookie.js

@@ -0,0 +1,96 @@
+/**
+* Cookie plugin
+*
+* Copyright (c) 2006 Klaus Hartl (stilbuero.de)
+* Dual licensed under the MIT and GPL licenses:
+* http://www.opensource.org/licenses/mit-license.php
+* http://www.gnu.org/licenses/gpl.html
+*
+*/
+
+/**
+* Create a cookie with the given name and value and other optional parameters.
+*
+* @example $.cookie('the_cookie', 'the_value');
+* @desc Set the value of a cookie.
+* @example $.cookie('the_cookie', 'the_value', { expires: 7, path: '/', domain: 'jquery.com', secure: true });
+* @desc Create a cookie with all available options.
+* @example $.cookie('the_cookie', 'the_value');
+* @desc Create a session cookie.
+* @example $.cookie('the_cookie', null);
+* @desc Delete a cookie by passing null as value. Keep in mind that you have to use the same path and domain
+*       used when the cookie was set.
+*
+* @param String name The name of the cookie.
+* @param String value The value of the cookie.
+* @param Object options An object literal containing key/value pairs to provide optional cookie attributes.
+* @option Number|Date expires Either an integer specifying the expiration date from now on in days or a Date object.
+*                             If a negative value is specified (e.g. a date in the past), the cookie will be deleted.
+*                             If set to null or omitted, the cookie will be a session cookie and will not be retained
+*                             when the the browser exits.
+* @option String path The value of the path atribute of the cookie (default: path of page that created the cookie).
+* @option String domain The value of the domain attribute of the cookie (default: domain of page that created the cookie).
+* @option Boolean secure If true, the secure attribute of the cookie will be set and the cookie transmission will
+*                        require a secure protocol (like HTTPS).
+* @type undefined
+*
+* @name $.cookie
+* @cat Plugins/Cookie
+* @author Klaus Hartl/klaus.hartl@stilbuero.de
+*/
+
+/**
+* Get the value of a cookie with the given name.
+*
+* @example $.cookie('the_cookie');
+* @desc Get the value of a cookie.
+*
+* @param String name The name of the cookie.
+* @return The value of the cookie.
+* @type String
+*
+* @name $.cookie
+* @cat Plugins/Cookie
+* @author Klaus Hartl/klaus.hartl@stilbuero.de
+*/
+jQuery.cookie = function(name, value, options) {
+    if (typeof value != 'undefined') { // name and value given, set cookie
+        options = options || {};
+        if (value === null) {
+            value = '';
+            options.expires = -1;
+        }
+        var expires = '';
+        if (options.expires && (typeof options.expires == 'number' || options.expires.toUTCString)) {
+            var date;
+            if (typeof options.expires == 'number') {
+                date = new Date();
+                date.setTime(date.getTime() + (options.expires * 24 * 60 * 60 * 1000));
+            } else {
+                date = options.expires;
+            }
+            expires = '; expires=' + date.toUTCString(); // use expires attribute, max-age is not supported by IE
+        }
+        // CAUTION: Needed to parenthesize options.path and options.domain
+        // in the following expressions, otherwise they evaluate to undefined
+        // in the packed version for some reason...
+        var path = options.path ? '; path=' + (options.path) : '';
+        var domain = options.domain ? '; domain=' + (options.domain) : '';
+        var secure = options.secure ? '; secure' : '';
+        document.cookie = [name, '=', encodeURIComponent(value), expires, path, domain, secure].join('');
+    } else { // only name given, get cookie
+        var cookieValue = null;
+        if (document.cookie && document.cookie != '') {
+            var cookies = document.cookie.split(';');
+            for (var i = 0; i < cookies.length; i++) {
+                var cookie = jQuery.trim(cookies[i]);
+                // Does this cookie string begin with the name we want?
+                if (cookie.substring(0, name.length + 1) == (name + '=')) {
+                    cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
+                    break;
+                }
+            }
+        }
+        return cookieValue;
+    }
+};

assets/monaco-editor/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 - present Microsoft Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

assets/monaco-editor/README.md

@@ -0,0 +1,96 @@
+# Monaco Editor
+
+[![Build Status](https://dev.azure.com/ms/monaco-editor/_apis/build/status/microsoft.monaco-editor?label=website)](https://dev.azure.com/ms/monaco-editor/_build/latest?definitionId=3)
+
+The Monaco Editor is the code editor which powers [VS Code](https://github.com/microsoft/vscode), with the features better described [here](https://code.visualstudio.com/docs/editor/editingevolved).
+
+Please note that this repository contains no source code for the code editor, it only contains the scripts to package everything together and ship the `monaco-editor` npm module.
+
+![image](https://user-images.githubusercontent.com/5047891/94183711-290c0780-fea3-11ea-90e3-c88ff9d21bd6.png)
+
+## Try it out
+
+Try the editor out [on our website](https://microsoft.github.io/monaco-editor/index.html).
+
+## Installing
+
+```
+$ npm install monaco-editor
+```
+
+You will get:
+
+- inside `esm`: ESM version of the editor (compatible with e.g. webpack)
+- inside `dev`: AMD bundled, not minified
+- inside `min`: AMD bundled, and minified
+- inside `min-maps`: source maps for `min`
+- `monaco.d.ts`: this specifies the API of the editor (this is what is actually versioned, everything else is considered private and might break with any release).
+
+It is recommended to develop against the `dev` version, and in production to use the `min` version.
+
+## Documentation
+
+- Learn how to integrate the editor with these [complete samples](./samples/).
+  - [Integrate the AMD version](./docs/integrate-amd.md).
+  - [Integrate the ESM version](./docs/integrate-esm.md)
+- Learn how to use the editor API and try out your own customizations in the [playground](https://microsoft.github.io/monaco-editor/playground.html).
+- Explore the [API docs](https://microsoft.github.io/monaco-editor/api/index.html) or read them straight from [`monaco.d.ts`](https://github.com/microsoft/monaco-editor/blob/main/website/typedoc/monaco.d.ts).
+- Read [this guide](https://github.com/microsoft/monaco-editor/wiki/Accessibility-Guide-for-Integrators) to ensure the editor is accessible to all your users!
+- Create a Monarch tokenizer for a new programming language [in the Monarch playground](https://microsoft.github.io/monaco-editor/monarch.html).
+- Ask questions on [StackOverflow](https://stackoverflow.com/questions/tagged/monaco-editor)! Search open and closed issues, there are a lot of tips in there!
+
+## Issues
+
+Create [issues](https://github.com/microsoft/monaco-editor/issues) in this repository for anything related to the Monaco Editor. Always mention **the version** of the editor when creating issues and **the browser** you're having trouble in. Please search for existing issues to avoid duplicates.
+
+## FAQ
+
+❓ **What is the relationship between VS Code and the Monaco Editor?**
+
+The Monaco Editor is generated straight from VS Code's sources with some shims around services the code needs to make it run in a web browser outside of its home.
+
+❓ **What is the relationship between VS Code's version and the Monaco Editor's version?**
+
+None. The Monaco Editor is a library and it reflects directly the source code.
+
+❓ **I've written an extension for VS Code, will it work on the Monaco Editor in a browser?**
+
+No.
+
+> Note: If the extension is fully based on the [LSP](https://microsoft.github.io/language-server-protocol/) and if the language server is authored in JavaScript, then it would be possible.
+
+❓ **Why all these web workers and why should I care?**
+
+Language services create web workers to compute heavy stuff outside of the UI thread. They cost hardly anything in terms of resource overhead and you shouldn't worry too much about them, as long as you get them to work (see above the cross-domain case).
+
+❓ **What is this `loader.js`? Can I use `require.js`?**
+
+It is an AMD loader that we use in VS Code. Yes.
+
+❓ **I see the warning "Could not create web worker". What should I do?**
+
+HTML5 does not allow pages loaded on `file://` to create web workers. Please load the editor with a web server on `http://` or `https://` schemes.
+
+❓ **Is the editor supported in mobile browsers or mobile web app frameworks?**
+
+No.
+
+❓ **Why doesn't the editor support TextMate grammars?**
+
+- Please see https://github.com/bolinfest/monaco-tm which puts together `monaco-editor`, `vscode-oniguruma` and `vscode-textmate` to get TM grammar support in the editor.
+
+❓ **What about IE 11 support?**
+
+- The Monaco Editor no longer supports IE 11. The last version that was tested on IE 11 is `0.18.1`.
+
+## Development setup
+
+Please see [CONTRIBUTING](./CONTRIBUTING.md)
+
+## Code of Conduct
+
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
+
+## License
+
+Licensed under the [MIT](https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt) License.

assets/monaco-editor/dev/vs/basic-languages/apex/apex.js

@@ -0,0 +1,336 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/apex/apex",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/apex/apex.ts
+  var apex_exports = {};
+  __export(apex_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: "<", close: ">" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*//\\s*(?:(?:#?region\\b)|(?:<editor-fold\\b))"),
+        end: new RegExp("^\\s*//\\s*(?:(?:#?endregion\\b)|(?:</editor-fold>))")
+      }
+    }
+  };
+  var keywords = [
+    "abstract",
+    "activate",
+    "and",
+    "any",
+    "array",
+    "as",
+    "asc",
+    "assert",
+    "autonomous",
+    "begin",
+    "bigdecimal",
+    "blob",
+    "boolean",
+    "break",
+    "bulk",
+    "by",
+    "case",
+    "cast",
+    "catch",
+    "char",
+    "class",
+    "collect",
+    "commit",
+    "const",
+    "continue",
+    "convertcurrency",
+    "decimal",
+    "default",
+    "delete",
+    "desc",
+    "do",
+    "double",
+    "else",
+    "end",
+    "enum",
+    "exception",
+    "exit",
+    "export",
+    "extends",
+    "false",
+    "final",
+    "finally",
+    "float",
+    "for",
+    "from",
+    "future",
+    "get",
+    "global",
+    "goto",
+    "group",
+    "having",
+    "hint",
+    "if",
+    "implements",
+    "import",
+    "in",
+    "inner",
+    "insert",
+    "instanceof",
+    "int",
+    "interface",
+    "into",
+    "join",
+    "last_90_days",
+    "last_month",
+    "last_n_days",
+    "last_week",
+    "like",
+    "limit",
+    "list",
+    "long",
+    "loop",
+    "map",
+    "merge",
+    "native",
+    "new",
+    "next_90_days",
+    "next_month",
+    "next_n_days",
+    "next_week",
+    "not",
+    "null",
+    "nulls",
+    "number",
+    "object",
+    "of",
+    "on",
+    "or",
+    "outer",
+    "override",
+    "package",
+    "parallel",
+    "pragma",
+    "private",
+    "protected",
+    "public",
+    "retrieve",
+    "return",
+    "returning",
+    "rollback",
+    "savepoint",
+    "search",
+    "select",
+    "set",
+    "short",
+    "sort",
+    "stat",
+    "static",
+    "strictfp",
+    "super",
+    "switch",
+    "synchronized",
+    "system",
+    "testmethod",
+    "then",
+    "this",
+    "this_month",
+    "this_week",
+    "throw",
+    "throws",
+    "today",
+    "tolabel",
+    "tomorrow",
+    "transaction",
+    "transient",
+    "trigger",
+    "true",
+    "try",
+    "type",
+    "undelete",
+    "update",
+    "upsert",
+    "using",
+    "virtual",
+    "void",
+    "volatile",
+    "webservice",
+    "when",
+    "where",
+    "while",
+    "yesterday"
+  ];
+  var uppercaseFirstLetter = (lowercase) => lowercase.charAt(0).toUpperCase() + lowercase.substr(1);
+  var keywordsWithCaseVariations = [];
+  keywords.forEach((lowercase) => {
+    keywordsWithCaseVariations.push(lowercase);
+    keywordsWithCaseVariations.push(lowercase.toUpperCase());
+    keywordsWithCaseVariations.push(uppercaseFirstLetter(lowercase));
+  });
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".apex",
+    keywords: keywordsWithCaseVariations,
+    operators: [
+      "=",
+      ">",
+      "<",
+      "!",
+      "~",
+      "?",
+      ":",
+      "==",
+      "<=",
+      ">=",
+      "!=",
+      "&&",
+      "||",
+      "++",
+      "--",
+      "+",
+      "-",
+      "*",
+      "/",
+      "&",
+      "|",
+      "^",
+      "%",
+      "<<",
+      ">>",
+      ">>>",
+      "+=",
+      "-=",
+      "*=",
+      "/=",
+      "&=",
+      "|=",
+      "^=",
+      "%=",
+      "<<=",
+      ">>=",
+      ">>>="
+    ],
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    digits: /\d+(_+\d+)*/,
+    octaldigits: /[0-7]+(_+[0-7]+)*/,
+    binarydigits: /[0-1]+(_+[0-1]+)*/,
+    hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+    tokenizer: {
+      root: [
+        [
+          /[a-z_$][\w$]*/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@default": "identifier"
+            }
+          }
+        ],
+        [
+          /[A-Z][\w\$]*/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@default": "type.identifier"
+            }
+          }
+        ],
+        { include: "@whitespace" },
+        [/[{}()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "delimiter",
+              "@default": ""
+            }
+          }
+        ],
+        [/@\s*[a-zA-Z_\$][\w\$]*/, "annotation"],
+        [/(@digits)[eE]([\-+]?(@digits))?[fFdD]?/, "number.float"],
+        [/(@digits)\.(@digits)([eE][\-+]?(@digits))?[fFdD]?/, "number.float"],
+        [/(@digits)[fFdD]/, "number.float"],
+        [/(@digits)[lL]?/, "number"],
+        [/[;,.]/, "delimiter"],
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        [/'([^'\\]|\\.)*$/, "string.invalid"],
+        [/"/, "string", '@string."'],
+        [/'/, "string", "@string.'"],
+        [/'[^\\']'/, "string"],
+        [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+        [/'/, "string.invalid"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/\/\*\*(?!\/)/, "comment.doc", "@apexdoc"],
+        [/\/\*/, "comment", "@comment"],
+        [/\/\/.*$/, "comment"]
+      ],
+      comment: [
+        [/[^\/*]+/, "comment"],
+        [/\*\//, "comment", "@pop"],
+        [/[\/*]/, "comment"]
+      ],
+      apexdoc: [
+        [/[^\/*]+/, "comment.doc"],
+        [/\*\//, "comment.doc", "@pop"],
+        [/[\/*]/, "comment.doc"]
+      ],
+      string: [
+        [/[^\\"']+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [
+          /["']/,
+          {
+            cases: {
+              "$#==$S2": { token: "string", next: "@pop" },
+              "@default": "string"
+            }
+          }
+        ]
+      ]
+    }
+  };
+  return apex_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/azcli/azcli.js

@@ -0,0 +1,91 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/azcli/azcli",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/azcli/azcli.ts
+  var azcli_exports = {};
+  __export(azcli_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "#"
+    }
+  };
+  var language = {
+    defaultToken: "keyword",
+    ignoreCase: true,
+    tokenPostfix: ".azcli",
+    str: /[^#\s]/,
+    tokenizer: {
+      root: [
+        { include: "@comment" },
+        [
+          /\s-+@str*\s*/,
+          {
+            cases: {
+              "@eos": { token: "key.identifier", next: "@popall" },
+              "@default": { token: "key.identifier", next: "@type" }
+            }
+          }
+        ],
+        [
+          /^-+@str*\s*/,
+          {
+            cases: {
+              "@eos": { token: "key.identifier", next: "@popall" },
+              "@default": { token: "key.identifier", next: "@type" }
+            }
+          }
+        ]
+      ],
+      type: [
+        { include: "@comment" },
+        [
+          /-+@str*\s*/,
+          {
+            cases: {
+              "@eos": { token: "key.identifier", next: "@popall" },
+              "@default": "key.identifier"
+            }
+          }
+        ],
+        [
+          /@str+\s*/,
+          {
+            cases: {
+              "@eos": { token: "string", next: "@popall" },
+              "@default": "string"
+            }
+          }
+        ]
+      ],
+      comment: [
+        [
+          /#.*$/,
+          {
+            cases: {
+              "@eos": { token: "comment", next: "@popall" }
+            }
+          }
+        ]
+      ]
+    }
+  };
+  return azcli_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/bat/bat.js

@@ -0,0 +1,112 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/bat/bat",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/bat/bat.ts
+  var bat_exports = {};
+  __export(bat_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "REM"
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' }
+    ],
+    surroundingPairs: [
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*(::\\s*|REM\\s+)#region"),
+        end: new RegExp("^\\s*(::\\s*|REM\\s+)#endregion")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    ignoreCase: true,
+    tokenPostfix: ".bat",
+    brackets: [
+      { token: "delimiter.bracket", open: "{", close: "}" },
+      { token: "delimiter.parenthesis", open: "(", close: ")" },
+      { token: "delimiter.square", open: "[", close: "]" }
+    ],
+    keywords: /call|defined|echo|errorlevel|exist|for|goto|if|pause|set|shift|start|title|not|pushd|popd/,
+    symbols: /[=><!~?&|+\-*\/\^;\.,]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    tokenizer: {
+      root: [
+        [/^(\s*)(rem(?:\s.*|))$/, ["", "comment"]],
+        [/(\@?)(@keywords)(?!\w)/, [{ token: "keyword" }, { token: "keyword.$2" }]],
+        [/[ \t\r\n]+/, ""],
+        [/setlocal(?!\w)/, "keyword.tag-setlocal"],
+        [/endlocal(?!\w)/, "keyword.tag-setlocal"],
+        [/[a-zA-Z_]\w*/, ""],
+        [/:\w*/, "metatag"],
+        [/%[^%]+%/, "variable"],
+        [/%%[\w]+(?!\w)/, "variable"],
+        [/[{}()\[\]]/, "@brackets"],
+        [/@symbols/, "delimiter"],
+        [/\d*\.\d+([eE][\-+]?\d+)?/, "number.float"],
+        [/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/, "number.hex"],
+        [/\d+/, "number"],
+        [/[;,.]/, "delimiter"],
+        [/"/, "string", '@string."'],
+        [/'/, "string", "@string.'"]
+      ],
+      string: [
+        [
+          /[^\\"'%]+/,
+          {
+            cases: {
+              "@eos": { token: "string", next: "@popall" },
+              "@default": "string"
+            }
+          }
+        ],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/%[\w ]+%/, "variable"],
+        [/%%[\w]+(?!\w)/, "variable"],
+        [
+          /["']/,
+          {
+            cases: {
+              "$#==$S2": { token: "string", next: "@pop" },
+              "@default": "string"
+            }
+          }
+        ],
+        [/$/, "string", "@popall"]
+      ]
+    }
+  };
+  return bat_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/bicep/bicep.js

@@ -0,0 +1,132 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/bicep/bicep",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/bicep/bicep.ts
+  var bicep_exports = {};
+  __export(bicep_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var bounded = (text) => `\\b${text}\\b`;
+  var identifierStart = "[_a-zA-Z]";
+  var identifierContinue = "[_a-zA-Z0-9]";
+  var identifier = bounded(`${identifierStart}${identifierContinue}*`);
+  var keywords = [
+    "targetScope",
+    "resource",
+    "module",
+    "param",
+    "var",
+    "output",
+    "for",
+    "in",
+    "if",
+    "existing"
+  ];
+  var namedLiterals = ["true", "false", "null"];
+  var nonCommentWs = `[ \\t\\r\\n]`;
+  var numericLiteral = `[0-9]+`;
+  var conf = {
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "'", close: "'" },
+      { open: "'''", close: "'''" }
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "'", close: "'", notIn: ["string", "comment"] },
+      { open: "'''", close: "'''", notIn: ["string", "comment"] }
+    ],
+    autoCloseBefore: ":.,=}])' \n	",
+    indentationRules: {
+      increaseIndentPattern: new RegExp("^((?!\\/\\/).)*(\\{[^}\"'`]*|\\([^)\"'`]*|\\[[^\\]\"'`]*)$"),
+      decreaseIndentPattern: new RegExp("^((?!.*?\\/\\*).*\\*/)?\\s*[\\}\\]].*$")
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".bicep",
+    brackets: [
+      { open: "{", close: "}", token: "delimiter.curly" },
+      { open: "[", close: "]", token: "delimiter.square" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" }
+    ],
+    symbols: /[=><!~?:&|+\-*/^%]+/,
+    keywords,
+    namedLiterals,
+    escapes: `\\\\(u{[0-9A-Fa-f]+}|n|r|t|\\\\|'|\\\${)`,
+    tokenizer: {
+      root: [{ include: "@expression" }, { include: "@whitespace" }],
+      stringVerbatim: [
+        { regex: `(|'|'')[^']`, action: { token: "string" } },
+        { regex: `'''`, action: { token: "string.quote", next: "@pop" } }
+      ],
+      stringLiteral: [
+        { regex: `\\\${`, action: { token: "delimiter.bracket", next: "@bracketCounting" } },
+        { regex: `[^\\\\'$]+`, action: { token: "string" } },
+        { regex: "@escapes", action: { token: "string.escape" } },
+        { regex: `\\\\.`, action: { token: "string.escape.invalid" } },
+        { regex: `'`, action: { token: "string", next: "@pop" } }
+      ],
+      bracketCounting: [
+        { regex: `{`, action: { token: "delimiter.bracket", next: "@bracketCounting" } },
+        { regex: `}`, action: { token: "delimiter.bracket", next: "@pop" } },
+        { include: "expression" }
+      ],
+      comment: [
+        { regex: `[^\\*]+`, action: { token: "comment" } },
+        { regex: `\\*\\/`, action: { token: "comment", next: "@pop" } },
+        { regex: `[\\/*]`, action: { token: "comment" } }
+      ],
+      whitespace: [
+        { regex: nonCommentWs },
+        { regex: `\\/\\*`, action: { token: "comment", next: "@comment" } },
+        { regex: `\\/\\/.*$`, action: { token: "comment" } }
+      ],
+      expression: [
+        { regex: `'''`, action: { token: "string.quote", next: "@stringVerbatim" } },
+        { regex: `'`, action: { token: "string.quote", next: "@stringLiteral" } },
+        { regex: numericLiteral, action: { token: "number" } },
+        {
+          regex: identifier,
+          action: {
+            cases: {
+              "@keywords": { token: "keyword" },
+              "@namedLiterals": { token: "keyword" },
+              "@default": { token: "identifier" }
+            }
+          }
+        }
+      ]
+    }
+  };
+  return bicep_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/cameligo/cameligo.js

@@ -0,0 +1,185 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/cameligo/cameligo",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/cameligo/cameligo.ts
+  var cameligo_exports = {};
+  __export(cameligo_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "//",
+      blockComment: ["(*", "*)"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"],
+      ["<", ">"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "<", close: ">" },
+      { open: "'", close: "'" },
+      { open: '"', close: '"' },
+      { open: "(*", close: "*)" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "<", close: ">" },
+      { open: "'", close: "'" },
+      { open: '"', close: '"' },
+      { open: "(*", close: "*)" }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".cameligo",
+    ignoreCase: true,
+    brackets: [
+      { open: "{", close: "}", token: "delimiter.curly" },
+      { open: "[", close: "]", token: "delimiter.square" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" },
+      { open: "<", close: ">", token: "delimiter.angle" }
+    ],
+    keywords: [
+      "abs",
+      "assert",
+      "block",
+      "Bytes",
+      "case",
+      "Crypto",
+      "Current",
+      "else",
+      "failwith",
+      "false",
+      "for",
+      "fun",
+      "if",
+      "in",
+      "let",
+      "let%entry",
+      "let%init",
+      "List",
+      "list",
+      "Map",
+      "map",
+      "match",
+      "match%nat",
+      "mod",
+      "not",
+      "operation",
+      "Operation",
+      "of",
+      "record",
+      "Set",
+      "set",
+      "sender",
+      "skip",
+      "source",
+      "String",
+      "then",
+      "to",
+      "true",
+      "type",
+      "with"
+    ],
+    typeKeywords: ["int", "unit", "string", "tz", "nat", "bool"],
+    operators: [
+      "=",
+      ">",
+      "<",
+      "<=",
+      ">=",
+      "<>",
+      ":",
+      ":=",
+      "and",
+      "mod",
+      "or",
+      "+",
+      "-",
+      "*",
+      "/",
+      "@",
+      "&",
+      "^",
+      "%",
+      "->",
+      "<-",
+      "&&",
+      "||"
+    ],
+    symbols: /[=><:@\^&|+\-*\/\^%]+/,
+    tokenizer: {
+      root: [
+        [
+          /[a-zA-Z_][\w]*/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@default": "identifier"
+            }
+          }
+        ],
+        { include: "@whitespace" },
+        [/[{}()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "delimiter",
+              "@default": ""
+            }
+          }
+        ],
+        [/\d*\.\d+([eE][\-+]?\d+)?/, "number.float"],
+        [/\$[0-9a-fA-F]{1,16}/, "number.hex"],
+        [/\d+/, "number"],
+        [/[;,.]/, "delimiter"],
+        [/'([^'\\]|\\.)*$/, "string.invalid"],
+        [/'/, "string", "@string"],
+        [/'[^\\']'/, "string"],
+        [/'/, "string.invalid"],
+        [/\#\d+/, "string"]
+      ],
+      comment: [
+        [/[^\(\*]+/, "comment"],
+        [/\*\)/, "comment", "@pop"],
+        [/\(\*/, "comment"]
+      ],
+      string: [
+        [/[^\\']+/, "string"],
+        [/\\./, "string.escape.invalid"],
+        [/'/, { token: "string.quote", bracket: "@close", next: "@pop" }]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, "white"],
+        [/\(\*/, "comment", "@comment"],
+        [/\/\/.*$/, "comment"]
+      ]
+    }
+  };
+  return cameligo_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/clojure/clojure.js

@@ -0,0 +1,771 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/clojure/clojure",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/clojure/clojure.ts
+  var clojure_exports = {};
+  __export(clojure_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: ";;"
+    },
+    brackets: [
+      ["[", "]"],
+      ["(", ")"],
+      ["{", "}"]
+    ],
+    autoClosingPairs: [
+      { open: "[", close: "]" },
+      { open: '"', close: '"' },
+      { open: "(", close: ")" },
+      { open: "{", close: "}" }
+    ],
+    surroundingPairs: [
+      { open: "[", close: "]" },
+      { open: '"', close: '"' },
+      { open: "(", close: ")" },
+      { open: "{", close: "}" }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    ignoreCase: true,
+    tokenPostfix: ".clj",
+    brackets: [
+      { open: "[", close: "]", token: "delimiter.square" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" },
+      { open: "{", close: "}", token: "delimiter.curly" }
+    ],
+    constants: ["true", "false", "nil"],
+    numbers: /^(?:[+\-]?\d+(?:(?:N|(?:[eE][+\-]?\d+))|(?:\.?\d*(?:M|(?:[eE][+\-]?\d+))?)|\/\d+|[xX][0-9a-fA-F]+|r[0-9a-zA-Z]+)?(?=[\\\[\]\s"#'(),;@^`{}~]|$))/,
+    characters: /^(?:\\(?:backspace|formfeed|newline|return|space|tab|o[0-7]{3}|u[0-9A-Fa-f]{4}|x[0-9A-Fa-f]{4}|.)?(?=[\\\[\]\s"(),;@^`{}~]|$))/,
+    escapes: /^\\(?:["'\\bfnrt]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    qualifiedSymbols: /^(?:(?:[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*(?:\.[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*)*\/)?(?:\/|[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*)*(?=[\\\[\]\s"(),;@^`{}~]|$))/,
+    specialForms: [
+      ".",
+      "catch",
+      "def",
+      "do",
+      "if",
+      "monitor-enter",
+      "monitor-exit",
+      "new",
+      "quote",
+      "recur",
+      "set!",
+      "throw",
+      "try",
+      "var"
+    ],
+    coreSymbols: [
+      "*",
+      "*'",
+      "*1",
+      "*2",
+      "*3",
+      "*agent*",
+      "*allow-unresolved-vars*",
+      "*assert*",
+      "*clojure-version*",
+      "*command-line-args*",
+      "*compile-files*",
+      "*compile-path*",
+      "*compiler-options*",
+      "*data-readers*",
+      "*default-data-reader-fn*",
+      "*e",
+      "*err*",
+      "*file*",
+      "*flush-on-newline*",
+      "*fn-loader*",
+      "*in*",
+      "*math-context*",
+      "*ns*",
+      "*out*",
+      "*print-dup*",
+      "*print-length*",
+      "*print-level*",
+      "*print-meta*",
+      "*print-namespace-maps*",
+      "*print-readably*",
+      "*read-eval*",
+      "*reader-resolver*",
+      "*source-path*",
+      "*suppress-read*",
+      "*unchecked-math*",
+      "*use-context-classloader*",
+      "*verbose-defrecords*",
+      "*warn-on-reflection*",
+      "+",
+      "+'",
+      "-",
+      "-'",
+      "->",
+      "->>",
+      "->ArrayChunk",
+      "->Eduction",
+      "->Vec",
+      "->VecNode",
+      "->VecSeq",
+      "-cache-protocol-fn",
+      "-reset-methods",
+      "..",
+      "/",
+      "<",
+      "<=",
+      "=",
+      "==",
+      ">",
+      ">=",
+      "EMPTY-NODE",
+      "Inst",
+      "StackTraceElement->vec",
+      "Throwable->map",
+      "accessor",
+      "aclone",
+      "add-classpath",
+      "add-watch",
+      "agent",
+      "agent-error",
+      "agent-errors",
+      "aget",
+      "alength",
+      "alias",
+      "all-ns",
+      "alter",
+      "alter-meta!",
+      "alter-var-root",
+      "amap",
+      "ancestors",
+      "and",
+      "any?",
+      "apply",
+      "areduce",
+      "array-map",
+      "as->",
+      "aset",
+      "aset-boolean",
+      "aset-byte",
+      "aset-char",
+      "aset-double",
+      "aset-float",
+      "aset-int",
+      "aset-long",
+      "aset-short",
+      "assert",
+      "assoc",
+      "assoc!",
+      "assoc-in",
+      "associative?",
+      "atom",
+      "await",
+      "await-for",
+      "await1",
+      "bases",
+      "bean",
+      "bigdec",
+      "bigint",
+      "biginteger",
+      "binding",
+      "bit-and",
+      "bit-and-not",
+      "bit-clear",
+      "bit-flip",
+      "bit-not",
+      "bit-or",
+      "bit-set",
+      "bit-shift-left",
+      "bit-shift-right",
+      "bit-test",
+      "bit-xor",
+      "boolean",
+      "boolean-array",
+      "boolean?",
+      "booleans",
+      "bound-fn",
+      "bound-fn*",
+      "bound?",
+      "bounded-count",
+      "butlast",
+      "byte",
+      "byte-array",
+      "bytes",
+      "bytes?",
+      "case",
+      "cast",
+      "cat",
+      "char",
+      "char-array",
+      "char-escape-string",
+      "char-name-string",
+      "char?",
+      "chars",
+      "chunk",
+      "chunk-append",
+      "chunk-buffer",
+      "chunk-cons",
+      "chunk-first",
+      "chunk-next",
+      "chunk-rest",
+      "chunked-seq?",
+      "class",
+      "class?",
+      "clear-agent-errors",
+      "clojure-version",
+      "coll?",
+      "comment",
+      "commute",
+      "comp",
+      "comparator",
+      "compare",
+      "compare-and-set!",
+      "compile",
+      "complement",
+      "completing",
+      "concat",
+      "cond",
+      "cond->",
+      "cond->>",
+      "condp",
+      "conj",
+      "conj!",
+      "cons",
+      "constantly",
+      "construct-proxy",
+      "contains?",
+      "count",
+      "counted?",
+      "create-ns",
+      "create-struct",
+      "cycle",
+      "dec",
+      "dec'",
+      "decimal?",
+      "declare",
+      "dedupe",
+      "default-data-readers",
+      "definline",
+      "definterface",
+      "defmacro",
+      "defmethod",
+      "defmulti",
+      "defn",
+      "defn-",
+      "defonce",
+      "defprotocol",
+      "defrecord",
+      "defstruct",
+      "deftype",
+      "delay",
+      "delay?",
+      "deliver",
+      "denominator",
+      "deref",
+      "derive",
+      "descendants",
+      "destructure",
+      "disj",
+      "disj!",
+      "dissoc",
+      "dissoc!",
+      "distinct",
+      "distinct?",
+      "doall",
+      "dorun",
+      "doseq",
+      "dosync",
+      "dotimes",
+      "doto",
+      "double",
+      "double-array",
+      "double?",
+      "doubles",
+      "drop",
+      "drop-last",
+      "drop-while",
+      "eduction",
+      "empty",
+      "empty?",
+      "ensure",
+      "ensure-reduced",
+      "enumeration-seq",
+      "error-handler",
+      "error-mode",
+      "eval",
+      "even?",
+      "every-pred",
+      "every?",
+      "ex-data",
+      "ex-info",
+      "extend",
+      "extend-protocol",
+      "extend-type",
+      "extenders",
+      "extends?",
+      "false?",
+      "ffirst",
+      "file-seq",
+      "filter",
+      "filterv",
+      "find",
+      "find-keyword",
+      "find-ns",
+      "find-protocol-impl",
+      "find-protocol-method",
+      "find-var",
+      "first",
+      "flatten",
+      "float",
+      "float-array",
+      "float?",
+      "floats",
+      "flush",
+      "fn",
+      "fn?",
+      "fnext",
+      "fnil",
+      "for",
+      "force",
+      "format",
+      "frequencies",
+      "future",
+      "future-call",
+      "future-cancel",
+      "future-cancelled?",
+      "future-done?",
+      "future?",
+      "gen-class",
+      "gen-interface",
+      "gensym",
+      "get",
+      "get-in",
+      "get-method",
+      "get-proxy-class",
+      "get-thread-bindings",
+      "get-validator",
+      "group-by",
+      "halt-when",
+      "hash",
+      "hash-combine",
+      "hash-map",
+      "hash-ordered-coll",
+      "hash-set",
+      "hash-unordered-coll",
+      "ident?",
+      "identical?",
+      "identity",
+      "if-let",
+      "if-not",
+      "if-some",
+      "ifn?",
+      "import",
+      "in-ns",
+      "inc",
+      "inc'",
+      "indexed?",
+      "init-proxy",
+      "inst-ms",
+      "inst-ms*",
+      "inst?",
+      "instance?",
+      "int",
+      "int-array",
+      "int?",
+      "integer?",
+      "interleave",
+      "intern",
+      "interpose",
+      "into",
+      "into-array",
+      "ints",
+      "io!",
+      "isa?",
+      "iterate",
+      "iterator-seq",
+      "juxt",
+      "keep",
+      "keep-indexed",
+      "key",
+      "keys",
+      "keyword",
+      "keyword?",
+      "last",
+      "lazy-cat",
+      "lazy-seq",
+      "let",
+      "letfn",
+      "line-seq",
+      "list",
+      "list*",
+      "list?",
+      "load",
+      "load-file",
+      "load-reader",
+      "load-string",
+      "loaded-libs",
+      "locking",
+      "long",
+      "long-array",
+      "longs",
+      "loop",
+      "macroexpand",
+      "macroexpand-1",
+      "make-array",
+      "make-hierarchy",
+      "map",
+      "map-entry?",
+      "map-indexed",
+      "map?",
+      "mapcat",
+      "mapv",
+      "max",
+      "max-key",
+      "memfn",
+      "memoize",
+      "merge",
+      "merge-with",
+      "meta",
+      "method-sig",
+      "methods",
+      "min",
+      "min-key",
+      "mix-collection-hash",
+      "mod",
+      "munge",
+      "name",
+      "namespace",
+      "namespace-munge",
+      "nat-int?",
+      "neg-int?",
+      "neg?",
+      "newline",
+      "next",
+      "nfirst",
+      "nil?",
+      "nnext",
+      "not",
+      "not-any?",
+      "not-empty",
+      "not-every?",
+      "not=",
+      "ns",
+      "ns-aliases",
+      "ns-imports",
+      "ns-interns",
+      "ns-map",
+      "ns-name",
+      "ns-publics",
+      "ns-refers",
+      "ns-resolve",
+      "ns-unalias",
+      "ns-unmap",
+      "nth",
+      "nthnext",
+      "nthrest",
+      "num",
+      "number?",
+      "numerator",
+      "object-array",
+      "odd?",
+      "or",
+      "parents",
+      "partial",
+      "partition",
+      "partition-all",
+      "partition-by",
+      "pcalls",
+      "peek",
+      "persistent!",
+      "pmap",
+      "pop",
+      "pop!",
+      "pop-thread-bindings",
+      "pos-int?",
+      "pos?",
+      "pr",
+      "pr-str",
+      "prefer-method",
+      "prefers",
+      "primitives-classnames",
+      "print",
+      "print-ctor",
+      "print-dup",
+      "print-method",
+      "print-simple",
+      "print-str",
+      "printf",
+      "println",
+      "println-str",
+      "prn",
+      "prn-str",
+      "promise",
+      "proxy",
+      "proxy-call-with-super",
+      "proxy-mappings",
+      "proxy-name",
+      "proxy-super",
+      "push-thread-bindings",
+      "pvalues",
+      "qualified-ident?",
+      "qualified-keyword?",
+      "qualified-symbol?",
+      "quot",
+      "rand",
+      "rand-int",
+      "rand-nth",
+      "random-sample",
+      "range",
+      "ratio?",
+      "rational?",
+      "rationalize",
+      "re-find",
+      "re-groups",
+      "re-matcher",
+      "re-matches",
+      "re-pattern",
+      "re-seq",
+      "read",
+      "read-line",
+      "read-string",
+      "reader-conditional",
+      "reader-conditional?",
+      "realized?",
+      "record?",
+      "reduce",
+      "reduce-kv",
+      "reduced",
+      "reduced?",
+      "reductions",
+      "ref",
+      "ref-history-count",
+      "ref-max-history",
+      "ref-min-history",
+      "ref-set",
+      "refer",
+      "refer-clojure",
+      "reify",
+      "release-pending-sends",
+      "rem",
+      "remove",
+      "remove-all-methods",
+      "remove-method",
+      "remove-ns",
+      "remove-watch",
+      "repeat",
+      "repeatedly",
+      "replace",
+      "replicate",
+      "require",
+      "reset!",
+      "reset-meta!",
+      "reset-vals!",
+      "resolve",
+      "rest",
+      "restart-agent",
+      "resultset-seq",
+      "reverse",
+      "reversible?",
+      "rseq",
+      "rsubseq",
+      "run!",
+      "satisfies?",
+      "second",
+      "select-keys",
+      "send",
+      "send-off",
+      "send-via",
+      "seq",
+      "seq?",
+      "seqable?",
+      "seque",
+      "sequence",
+      "sequential?",
+      "set",
+      "set-agent-send-executor!",
+      "set-agent-send-off-executor!",
+      "set-error-handler!",
+      "set-error-mode!",
+      "set-validator!",
+      "set?",
+      "short",
+      "short-array",
+      "shorts",
+      "shuffle",
+      "shutdown-agents",
+      "simple-ident?",
+      "simple-keyword?",
+      "simple-symbol?",
+      "slurp",
+      "some",
+      "some->",
+      "some->>",
+      "some-fn",
+      "some?",
+      "sort",
+      "sort-by",
+      "sorted-map",
+      "sorted-map-by",
+      "sorted-set",
+      "sorted-set-by",
+      "sorted?",
+      "special-symbol?",
+      "spit",
+      "split-at",
+      "split-with",
+      "str",
+      "string?",
+      "struct",
+      "struct-map",
+      "subs",
+      "subseq",
+      "subvec",
+      "supers",
+      "swap!",
+      "swap-vals!",
+      "symbol",
+      "symbol?",
+      "sync",
+      "tagged-literal",
+      "tagged-literal?",
+      "take",
+      "take-last",
+      "take-nth",
+      "take-while",
+      "test",
+      "the-ns",
+      "thread-bound?",
+      "time",
+      "to-array",
+      "to-array-2d",
+      "trampoline",
+      "transduce",
+      "transient",
+      "tree-seq",
+      "true?",
+      "type",
+      "unchecked-add",
+      "unchecked-add-int",
+      "unchecked-byte",
+      "unchecked-char",
+      "unchecked-dec",
+      "unchecked-dec-int",
+      "unchecked-divide-int",
+      "unchecked-double",
+      "unchecked-float",
+      "unchecked-inc",
+      "unchecked-inc-int",
+      "unchecked-int",
+      "unchecked-long",
+      "unchecked-multiply",
+      "unchecked-multiply-int",
+      "unchecked-negate",
+      "unchecked-negate-int",
+      "unchecked-remainder-int",
+      "unchecked-short",
+      "unchecked-subtract",
+      "unchecked-subtract-int",
+      "underive",
+      "unquote",
+      "unquote-splicing",
+      "unreduced",
+      "unsigned-bit-shift-right",
+      "update",
+      "update-in",
+      "update-proxy",
+      "uri?",
+      "use",
+      "uuid?",
+      "val",
+      "vals",
+      "var-get",
+      "var-set",
+      "var?",
+      "vary-meta",
+      "vec",
+      "vector",
+      "vector-of",
+      "vector?",
+      "volatile!",
+      "volatile?",
+      "vreset!",
+      "vswap!",
+      "when",
+      "when-first",
+      "when-let",
+      "when-not",
+      "when-some",
+      "while",
+      "with-bindings",
+      "with-bindings*",
+      "with-in-str",
+      "with-loading-context",
+      "with-local-vars",
+      "with-meta",
+      "with-open",
+      "with-out-str",
+      "with-precision",
+      "with-redefs",
+      "with-redefs-fn",
+      "xml-seq",
+      "zero?",
+      "zipmap"
+    ],
+    tokenizer: {
+      root: [
+        { include: "@whitespace" },
+        [/@numbers/, "number"],
+        [/@characters/, "string"],
+        { include: "@string" },
+        [/[()\[\]{}]/, "@brackets"],
+        [/\/#"(?:\.|(?:")|[^"\n])*"\/g/, "regexp"],
+        [/[#'@^`~]/, "meta"],
+        [
+          /@qualifiedSymbols/,
+          {
+            cases: {
+              "^:.+$": "constant",
+              "@specialForms": "keyword",
+              "@coreSymbols": "keyword",
+              "@constants": "constant",
+              "@default": "identifier"
+            }
+          }
+        ]
+      ],
+      whitespace: [
+        [/[\s,]+/, "white"],
+        [/;.*$/, "comment"],
+        [/\(comment\b/, "comment", "@comment"]
+      ],
+      comment: [
+        [/\(/, "comment", "@push"],
+        [/\)/, "comment", "@pop"],
+        [/[^()]/, "comment"]
+      ],
+      string: [[/"/, "string", "@multiLineString"]],
+      multiLineString: [
+        [/"/, "string", "@popall"],
+        [/@escapes/, "string.escape"],
+        [/./, "string"]
+      ]
+    }
+  };
+  return clojure_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/coffee/coffee.js

@@ -0,0 +1,245 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/coffee/coffee",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/coffee/coffee.ts
+  var coffee_exports = {};
+  __export(coffee_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#%\^\&\*\(\)\=\$\-\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+    comments: {
+      blockComment: ["###", "###"],
+      lineComment: "#"
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*#region\\b"),
+        end: new RegExp("^\\s*#endregion\\b")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    ignoreCase: true,
+    tokenPostfix: ".coffee",
+    brackets: [
+      { open: "{", close: "}", token: "delimiter.curly" },
+      { open: "[", close: "]", token: "delimiter.square" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" }
+    ],
+    regEx: /\/(?!\/\/)(?:[^\/\\]|\\.)*\/[igm]*/,
+    keywords: [
+      "and",
+      "or",
+      "is",
+      "isnt",
+      "not",
+      "on",
+      "yes",
+      "@",
+      "no",
+      "off",
+      "true",
+      "false",
+      "null",
+      "this",
+      "new",
+      "delete",
+      "typeof",
+      "in",
+      "instanceof",
+      "return",
+      "throw",
+      "break",
+      "continue",
+      "debugger",
+      "if",
+      "else",
+      "switch",
+      "for",
+      "while",
+      "do",
+      "try",
+      "catch",
+      "finally",
+      "class",
+      "extends",
+      "super",
+      "undefined",
+      "then",
+      "unless",
+      "until",
+      "loop",
+      "of",
+      "by",
+      "when"
+    ],
+    symbols: /[=><!~?&%|+\-*\/\^\.,\:]+/,
+    escapes: /\\(?:[abfnrtv\\"'$]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    tokenizer: {
+      root: [
+        [/\@[a-zA-Z_]\w*/, "variable.predefined"],
+        [
+          /[a-zA-Z_]\w*/,
+          {
+            cases: {
+              this: "variable.predefined",
+              "@keywords": { token: "keyword.$0" },
+              "@default": ""
+            }
+          }
+        ],
+        [/[ \t\r\n]+/, ""],
+        [/###/, "comment", "@comment"],
+        [/#.*$/, "comment"],
+        ["///", { token: "regexp", next: "@hereregexp" }],
+        [/^(\s*)(@regEx)/, ["", "regexp"]],
+        [/(\()(\s*)(@regEx)/, ["@brackets", "", "regexp"]],
+        [/(\,)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+        [/(\=)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+        [/(\:)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+        [/(\[)(\s*)(@regEx)/, ["@brackets", "", "regexp"]],
+        [/(\!)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+        [/(\&)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+        [/(\|)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+        [/(\?)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+        [/(\{)(\s*)(@regEx)/, ["@brackets", "", "regexp"]],
+        [/(\;)(\s*)(@regEx)/, ["", "", "regexp"]],
+        [
+          /}/,
+          {
+            cases: {
+              "$S2==interpolatedstring": {
+                token: "string",
+                next: "@pop"
+              },
+              "@default": "@brackets"
+            }
+          }
+        ],
+        [/[{}()\[\]]/, "@brackets"],
+        [/@symbols/, "delimiter"],
+        [/\d+[eE]([\-+]?\d+)?/, "number.float"],
+        [/\d+\.\d+([eE][\-+]?\d+)?/, "number.float"],
+        [/0[xX][0-9a-fA-F]+/, "number.hex"],
+        [/0[0-7]+(?!\d)/, "number.octal"],
+        [/\d+/, "number"],
+        [/[,.]/, "delimiter"],
+        [/"""/, "string", '@herestring."""'],
+        [/'''/, "string", "@herestring.'''"],
+        [
+          /"/,
+          {
+            cases: {
+              "@eos": "string",
+              "@default": { token: "string", next: '@string."' }
+            }
+          }
+        ],
+        [
+          /'/,
+          {
+            cases: {
+              "@eos": "string",
+              "@default": { token: "string", next: "@string.'" }
+            }
+          }
+        ]
+      ],
+      string: [
+        [/[^"'\#\\]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\./, "string.escape.invalid"],
+        [/\./, "string.escape.invalid"],
+        [
+          /#{/,
+          {
+            cases: {
+              '$S2=="': {
+                token: "string",
+                next: "root.interpolatedstring"
+              },
+              "@default": "string"
+            }
+          }
+        ],
+        [
+          /["']/,
+          {
+            cases: {
+              "$#==$S2": { token: "string", next: "@pop" },
+              "@default": "string"
+            }
+          }
+        ],
+        [/#/, "string"]
+      ],
+      herestring: [
+        [
+          /("""|''')/,
+          {
+            cases: {
+              "$1==$S2": { token: "string", next: "@pop" },
+              "@default": "string"
+            }
+          }
+        ],
+        [/[^#\\'"]+/, "string"],
+        [/['"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\./, "string.escape.invalid"],
+        [/#{/, { token: "string.quote", next: "root.interpolatedstring" }],
+        [/#/, "string"]
+      ],
+      comment: [
+        [/[^#]+/, "comment"],
+        [/###/, "comment", "@pop"],
+        [/#/, "comment"]
+      ],
+      hereregexp: [
+        [/[^\\\/#]+/, "regexp"],
+        [/\\./, "regexp"],
+        [/#.*$/, "comment"],
+        ["///[igm]*", { token: "regexp", next: "@pop" }],
+        [/\//, "regexp"]
+      ]
+    }
+  };
+  return coffee_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/cpp/cpp.js

@@ -0,0 +1,404 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/cpp/cpp",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/cpp/cpp.ts
+  var cpp_exports = {};
+  __export(cpp_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "[", close: "]" },
+      { open: "{", close: "}" },
+      { open: "(", close: ")" },
+      { open: "'", close: "'", notIn: ["string", "comment"] },
+      { open: '"', close: '"', notIn: ["string"] }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*#pragma\\s+region\\b"),
+        end: new RegExp("^\\s*#pragma\\s+endregion\\b")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".cpp",
+    brackets: [
+      { token: "delimiter.curly", open: "{", close: "}" },
+      { token: "delimiter.parenthesis", open: "(", close: ")" },
+      { token: "delimiter.square", open: "[", close: "]" },
+      { token: "delimiter.angle", open: "<", close: ">" }
+    ],
+    keywords: [
+      "abstract",
+      "amp",
+      "array",
+      "auto",
+      "bool",
+      "break",
+      "case",
+      "catch",
+      "char",
+      "class",
+      "const",
+      "constexpr",
+      "const_cast",
+      "continue",
+      "cpu",
+      "decltype",
+      "default",
+      "delegate",
+      "delete",
+      "do",
+      "double",
+      "dynamic_cast",
+      "each",
+      "else",
+      "enum",
+      "event",
+      "explicit",
+      "export",
+      "extern",
+      "false",
+      "final",
+      "finally",
+      "float",
+      "for",
+      "friend",
+      "gcnew",
+      "generic",
+      "goto",
+      "if",
+      "in",
+      "initonly",
+      "inline",
+      "int",
+      "interface",
+      "interior_ptr",
+      "internal",
+      "literal",
+      "long",
+      "mutable",
+      "namespace",
+      "new",
+      "noexcept",
+      "nullptr",
+      "__nullptr",
+      "operator",
+      "override",
+      "partial",
+      "pascal",
+      "pin_ptr",
+      "private",
+      "property",
+      "protected",
+      "public",
+      "ref",
+      "register",
+      "reinterpret_cast",
+      "restrict",
+      "return",
+      "safe_cast",
+      "sealed",
+      "short",
+      "signed",
+      "sizeof",
+      "static",
+      "static_assert",
+      "static_cast",
+      "struct",
+      "switch",
+      "template",
+      "this",
+      "thread_local",
+      "throw",
+      "tile_static",
+      "true",
+      "try",
+      "typedef",
+      "typeid",
+      "typename",
+      "union",
+      "unsigned",
+      "using",
+      "virtual",
+      "void",
+      "volatile",
+      "wchar_t",
+      "where",
+      "while",
+      "_asm",
+      "_based",
+      "_cdecl",
+      "_declspec",
+      "_fastcall",
+      "_if_exists",
+      "_if_not_exists",
+      "_inline",
+      "_multiple_inheritance",
+      "_pascal",
+      "_single_inheritance",
+      "_stdcall",
+      "_virtual_inheritance",
+      "_w64",
+      "__abstract",
+      "__alignof",
+      "__asm",
+      "__assume",
+      "__based",
+      "__box",
+      "__builtin_alignof",
+      "__cdecl",
+      "__clrcall",
+      "__declspec",
+      "__delegate",
+      "__event",
+      "__except",
+      "__fastcall",
+      "__finally",
+      "__forceinline",
+      "__gc",
+      "__hook",
+      "__identifier",
+      "__if_exists",
+      "__if_not_exists",
+      "__inline",
+      "__int128",
+      "__int16",
+      "__int32",
+      "__int64",
+      "__int8",
+      "__interface",
+      "__leave",
+      "__m128",
+      "__m128d",
+      "__m128i",
+      "__m256",
+      "__m256d",
+      "__m256i",
+      "__m64",
+      "__multiple_inheritance",
+      "__newslot",
+      "__nogc",
+      "__noop",
+      "__nounwind",
+      "__novtordisp",
+      "__pascal",
+      "__pin",
+      "__pragma",
+      "__property",
+      "__ptr32",
+      "__ptr64",
+      "__raise",
+      "__restrict",
+      "__resume",
+      "__sealed",
+      "__single_inheritance",
+      "__stdcall",
+      "__super",
+      "__thiscall",
+      "__try",
+      "__try_cast",
+      "__typeof",
+      "__unaligned",
+      "__unhook",
+      "__uuidof",
+      "__value",
+      "__virtual_inheritance",
+      "__w64",
+      "__wchar_t"
+    ],
+    operators: [
+      "=",
+      ">",
+      "<",
+      "!",
+      "~",
+      "?",
+      ":",
+      "==",
+      "<=",
+      ">=",
+      "!=",
+      "&&",
+      "||",
+      "++",
+      "--",
+      "+",
+      "-",
+      "*",
+      "/",
+      "&",
+      "|",
+      "^",
+      "%",
+      "<<",
+      ">>",
+      ">>>",
+      "+=",
+      "-=",
+      "*=",
+      "/=",
+      "&=",
+      "|=",
+      "^=",
+      "%=",
+      "<<=",
+      ">>=",
+      ">>>="
+    ],
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    integersuffix: /([uU](ll|LL|l|L)|(ll|LL|l|L)?[uU]?)/,
+    floatsuffix: /[fFlL]?/,
+    encoding: /u|u8|U|L/,
+    tokenizer: {
+      root: [
+        [/@encoding?R\"(?:([^ ()\\\t]*))\(/, { token: "string.raw.begin", next: "@raw.$1" }],
+        [
+          /[a-zA-Z_]\w*/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@default": "identifier"
+            }
+          }
+        ],
+        [/^\s*#\s*include/, { token: "keyword.directive.include", next: "@include" }],
+        [/^\s*#\s*\w+/, "keyword.directive"],
+        { include: "@whitespace" },
+        [/\[\s*\[/, { token: "annotation", next: "@annotation" }],
+        [/[{}()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "delimiter",
+              "@default": ""
+            }
+          }
+        ],
+        [/\d*\d+[eE]([\-+]?\d+)?(@floatsuffix)/, "number.float"],
+        [/\d*\.\d+([eE][\-+]?\d+)?(@floatsuffix)/, "number.float"],
+        [/0[xX][0-9a-fA-F']*[0-9a-fA-F](@integersuffix)/, "number.hex"],
+        [/0[0-7']*[0-7](@integersuffix)/, "number.octal"],
+        [/0[bB][0-1']*[0-1](@integersuffix)/, "number.binary"],
+        [/\d[\d']*\d(@integersuffix)/, "number"],
+        [/\d(@integersuffix)/, "number"],
+        [/[;,.]/, "delimiter"],
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        [/"/, "string", "@string"],
+        [/'[^\\']'/, "string"],
+        [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+        [/'/, "string.invalid"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/\/\*\*(?!\/)/, "comment.doc", "@doccomment"],
+        [/\/\*/, "comment", "@comment"],
+        [/\/\/.*\\$/, "comment", "@linecomment"],
+        [/\/\/.*$/, "comment"]
+      ],
+      comment: [
+        [/[^\/*]+/, "comment"],
+        [/\*\//, "comment", "@pop"],
+        [/[\/*]/, "comment"]
+      ],
+      linecomment: [
+        [/.*[^\\]$/, "comment", "@pop"],
+        [/[^]+/, "comment"]
+      ],
+      doccomment: [
+        [/[^\/*]+/, "comment.doc"],
+        [/\*\//, "comment.doc", "@pop"],
+        [/[\/*]/, "comment.doc"]
+      ],
+      string: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, "string", "@pop"]
+      ],
+      raw: [
+        [
+          /(.*)(\))(?:([^ ()\\\t"]*))(\")/,
+          {
+            cases: {
+              "$3==$S2": [
+                "string.raw",
+                "string.raw.end",
+                "string.raw.end",
+                { token: "string.raw.end", next: "@pop" }
+              ],
+              "@default": ["string.raw", "string.raw", "string.raw", "string.raw"]
+            }
+          }
+        ],
+        [/.*/, "string.raw"]
+      ],
+      annotation: [
+        { include: "@whitespace" },
+        [/using|alignas/, "keyword"],
+        [/[a-zA-Z0-9_]+/, "annotation"],
+        [/[,:]/, "delimiter"],
+        [/[()]/, "@brackets"],
+        [/\]\s*\]/, { token: "annotation", next: "@pop" }]
+      ],
+      include: [
+        [
+          /(\s*)(<)([^<>]*)(>)/,
+          [
+            "",
+            "keyword.directive.include.begin",
+            "string.include.identifier",
+            { token: "keyword.directive.include.end", next: "@pop" }
+          ]
+        ],
+        [
+          /(\s*)(")([^"]*)(")/,
+          [
+            "",
+            "keyword.directive.include.begin",
+            "string.include.identifier",
+            { token: "keyword.directive.include.end", next: "@pop" }
+          ]
+        ]
+      ]
+    }
+  };
+  return cpp_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/csharp/csharp.js

@@ -0,0 +1,337 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/csharp/csharp",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/csharp/csharp.ts
+  var csharp_exports = {};
+  __export(csharp_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\$\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "'", close: "'", notIn: ["string", "comment"] },
+      { open: '"', close: '"', notIn: ["string", "comment"] }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "<", close: ">" },
+      { open: "'", close: "'" },
+      { open: '"', close: '"' }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*#region\\b"),
+        end: new RegExp("^\\s*#endregion\\b")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".cs",
+    brackets: [
+      { open: "{", close: "}", token: "delimiter.curly" },
+      { open: "[", close: "]", token: "delimiter.square" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" },
+      { open: "<", close: ">", token: "delimiter.angle" }
+    ],
+    keywords: [
+      "extern",
+      "alias",
+      "using",
+      "bool",
+      "decimal",
+      "sbyte",
+      "byte",
+      "short",
+      "ushort",
+      "int",
+      "uint",
+      "long",
+      "ulong",
+      "char",
+      "float",
+      "double",
+      "object",
+      "dynamic",
+      "string",
+      "assembly",
+      "is",
+      "as",
+      "ref",
+      "out",
+      "this",
+      "base",
+      "new",
+      "typeof",
+      "void",
+      "checked",
+      "unchecked",
+      "default",
+      "delegate",
+      "var",
+      "const",
+      "if",
+      "else",
+      "switch",
+      "case",
+      "while",
+      "do",
+      "for",
+      "foreach",
+      "in",
+      "break",
+      "continue",
+      "goto",
+      "return",
+      "throw",
+      "try",
+      "catch",
+      "finally",
+      "lock",
+      "yield",
+      "from",
+      "let",
+      "where",
+      "join",
+      "on",
+      "equals",
+      "into",
+      "orderby",
+      "ascending",
+      "descending",
+      "select",
+      "group",
+      "by",
+      "namespace",
+      "partial",
+      "class",
+      "field",
+      "event",
+      "method",
+      "param",
+      "public",
+      "protected",
+      "internal",
+      "private",
+      "abstract",
+      "sealed",
+      "static",
+      "struct",
+      "readonly",
+      "volatile",
+      "virtual",
+      "override",
+      "params",
+      "get",
+      "set",
+      "add",
+      "remove",
+      "operator",
+      "true",
+      "false",
+      "implicit",
+      "explicit",
+      "interface",
+      "enum",
+      "null",
+      "async",
+      "await",
+      "fixed",
+      "sizeof",
+      "stackalloc",
+      "unsafe",
+      "nameof",
+      "when"
+    ],
+    namespaceFollows: ["namespace", "using"],
+    parenFollows: ["if", "for", "while", "switch", "foreach", "using", "catch", "when"],
+    operators: [
+      "=",
+      "??",
+      "||",
+      "&&",
+      "|",
+      "^",
+      "&",
+      "==",
+      "!=",
+      "<=",
+      ">=",
+      "<<",
+      "+",
+      "-",
+      "*",
+      "/",
+      "%",
+      "!",
+      "~",
+      "++",
+      "--",
+      "+=",
+      "-=",
+      "*=",
+      "/=",
+      "%=",
+      "&=",
+      "|=",
+      "^=",
+      "<<=",
+      ">>=",
+      ">>",
+      "=>"
+    ],
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    tokenizer: {
+      root: [
+        [
+          /\@?[a-zA-Z_]\w*/,
+          {
+            cases: {
+              "@namespaceFollows": {
+                token: "keyword.$0",
+                next: "@namespace"
+              },
+              "@keywords": {
+                token: "keyword.$0",
+                next: "@qualified"
+              },
+              "@default": { token: "identifier", next: "@qualified" }
+            }
+          }
+        ],
+        { include: "@whitespace" },
+        [
+          /}/,
+          {
+            cases: {
+              "$S2==interpolatedstring": {
+                token: "string.quote",
+                next: "@pop"
+              },
+              "$S2==litinterpstring": {
+                token: "string.quote",
+                next: "@pop"
+              },
+              "@default": "@brackets"
+            }
+          }
+        ],
+        [/[{}()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "delimiter",
+              "@default": ""
+            }
+          }
+        ],
+        [/[0-9_]*\.[0-9_]+([eE][\-+]?\d+)?[fFdD]?/, "number.float"],
+        [/0[xX][0-9a-fA-F_]+/, "number.hex"],
+        [/0[bB][01_]+/, "number.hex"],
+        [/[0-9_]+/, "number"],
+        [/[;,.]/, "delimiter"],
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        [/"/, { token: "string.quote", next: "@string" }],
+        [/\$\@"/, { token: "string.quote", next: "@litinterpstring" }],
+        [/\@"/, { token: "string.quote", next: "@litstring" }],
+        [/\$"/, { token: "string.quote", next: "@interpolatedstring" }],
+        [/'[^\\']'/, "string"],
+        [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+        [/'/, "string.invalid"]
+      ],
+      qualified: [
+        [
+          /[a-zA-Z_][\w]*/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@default": "identifier"
+            }
+          }
+        ],
+        [/\./, "delimiter"],
+        ["", "", "@pop"]
+      ],
+      namespace: [
+        { include: "@whitespace" },
+        [/[A-Z]\w*/, "namespace"],
+        [/[\.=]/, "delimiter"],
+        ["", "", "@pop"]
+      ],
+      comment: [
+        [/[^\/*]+/, "comment"],
+        ["\\*/", "comment", "@pop"],
+        [/[\/*]/, "comment"]
+      ],
+      string: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, { token: "string.quote", next: "@pop" }]
+      ],
+      litstring: [
+        [/[^"]+/, "string"],
+        [/""/, "string.escape"],
+        [/"/, { token: "string.quote", next: "@pop" }]
+      ],
+      litinterpstring: [
+        [/[^"{]+/, "string"],
+        [/""/, "string.escape"],
+        [/{{/, "string.escape"],
+        [/}}/, "string.escape"],
+        [/{/, { token: "string.quote", next: "root.litinterpstring" }],
+        [/"/, { token: "string.quote", next: "@pop" }]
+      ],
+      interpolatedstring: [
+        [/[^\\"{]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/{{/, "string.escape"],
+        [/}}/, "string.escape"],
+        [/{/, { token: "string.quote", next: "root.interpolatedstring" }],
+        [/"/, { token: "string.quote", next: "@pop" }]
+      ],
+      whitespace: [
+        [/^[ \t\v\f]*#((r)|(load))(?=\s)/, "directive.csx"],
+        [/^[ \t\v\f]*#\w.*$/, "namespace.cpp"],
+        [/[ \t\v\f\r\n]+/, ""],
+        [/\/\*/, "comment", "@comment"],
+        [/\/\/.*$/, "comment"]
+      ]
+    }
+  };
+  return csharp_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/csp/csp.js

@@ -0,0 +1,74 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/csp/csp",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/csp/csp.ts
+  var csp_exports = {};
+  __export(csp_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    brackets: [],
+    autoClosingPairs: [],
+    surroundingPairs: []
+  };
+  var language = {
+    keywords: [],
+    typeKeywords: [],
+    tokenPostfix: ".csp",
+    operators: [],
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    tokenizer: {
+      root: [
+        [/child-src/, "string.quote"],
+        [/connect-src/, "string.quote"],
+        [/default-src/, "string.quote"],
+        [/font-src/, "string.quote"],
+        [/frame-src/, "string.quote"],
+        [/img-src/, "string.quote"],
+        [/manifest-src/, "string.quote"],
+        [/media-src/, "string.quote"],
+        [/object-src/, "string.quote"],
+        [/script-src/, "string.quote"],
+        [/style-src/, "string.quote"],
+        [/worker-src/, "string.quote"],
+        [/base-uri/, "string.quote"],
+        [/plugin-types/, "string.quote"],
+        [/sandbox/, "string.quote"],
+        [/disown-opener/, "string.quote"],
+        [/form-action/, "string.quote"],
+        [/frame-ancestors/, "string.quote"],
+        [/report-uri/, "string.quote"],
+        [/report-to/, "string.quote"],
+        [/upgrade-insecure-requests/, "string.quote"],
+        [/block-all-mixed-content/, "string.quote"],
+        [/require-sri-for/, "string.quote"],
+        [/reflected-xss/, "string.quote"],
+        [/referrer/, "string.quote"],
+        [/policy-uri/, "string.quote"],
+        [/'self'/, "string.quote"],
+        [/'unsafe-inline'/, "string.quote"],
+        [/'unsafe-eval'/, "string.quote"],
+        [/'strict-dynamic'/, "string.quote"],
+        [/'unsafe-hashed-attributes'/, "string.quote"]
+      ]
+    }
+  };
+  return csp_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/css/css.js

@@ -0,0 +1,201 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/css/css",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/css/css.ts
+  var css_exports = {};
+  __export(css_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    wordPattern: /(#?-?\d*\.\d\w*%?)|((::|[@#.!:])?[\w-?]+%?)|::|[@#.!:]/g,
+    comments: {
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}", notIn: ["string", "comment"] },
+      { open: "[", close: "]", notIn: ["string", "comment"] },
+      { open: "(", close: ")", notIn: ["string", "comment"] },
+      { open: '"', close: '"', notIn: ["string", "comment"] },
+      { open: "'", close: "'", notIn: ["string", "comment"] }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*\\/\\*\\s*#region\\b\\s*(.*?)\\s*\\*\\/"),
+        end: new RegExp("^\\s*\\/\\*\\s*#endregion\\b.*\\*\\/")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".css",
+    ws: "[ 	\n\r\f]*",
+    identifier: "-?-?([a-zA-Z]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*",
+    brackets: [
+      { open: "{", close: "}", token: "delimiter.bracket" },
+      { open: "[", close: "]", token: "delimiter.bracket" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" },
+      { open: "<", close: ">", token: "delimiter.angle" }
+    ],
+    tokenizer: {
+      root: [{ include: "@selector" }],
+      selector: [
+        { include: "@comments" },
+        { include: "@import" },
+        { include: "@strings" },
+        [
+          "[@](keyframes|-webkit-keyframes|-moz-keyframes|-o-keyframes)",
+          { token: "keyword", next: "@keyframedeclaration" }
+        ],
+        ["[@](page|content|font-face|-moz-document)", { token: "keyword" }],
+        ["[@](charset|namespace)", { token: "keyword", next: "@declarationbody" }],
+        [
+          "(url-prefix)(\\()",
+          ["attribute.value", { token: "delimiter.parenthesis", next: "@urldeclaration" }]
+        ],
+        [
+          "(url)(\\()",
+          ["attribute.value", { token: "delimiter.parenthesis", next: "@urldeclaration" }]
+        ],
+        { include: "@selectorname" },
+        ["[\\*]", "tag"],
+        ["[>\\+,]", "delimiter"],
+        ["\\[", { token: "delimiter.bracket", next: "@selectorattribute" }],
+        ["{", { token: "delimiter.bracket", next: "@selectorbody" }]
+      ],
+      selectorbody: [
+        { include: "@comments" },
+        ["[*_]?@identifier@ws:(?=(\\s|\\d|[^{;}]*[;}]))", "attribute.name", "@rulevalue"],
+        ["}", { token: "delimiter.bracket", next: "@pop" }]
+      ],
+      selectorname: [
+        ["(\\.|#(?=[^{])|%|(@identifier)|:)+", "tag"]
+      ],
+      selectorattribute: [{ include: "@term" }, ["]", { token: "delimiter.bracket", next: "@pop" }]],
+      term: [
+        { include: "@comments" },
+        [
+          "(url-prefix)(\\()",
+          ["attribute.value", { token: "delimiter.parenthesis", next: "@urldeclaration" }]
+        ],
+        [
+          "(url)(\\()",
+          ["attribute.value", { token: "delimiter.parenthesis", next: "@urldeclaration" }]
+        ],
+        { include: "@functioninvocation" },
+        { include: "@numbers" },
+        { include: "@name" },
+        { include: "@strings" },
+        ["([<>=\\+\\-\\*\\/\\^\\|\\~,])", "delimiter"],
+        [",", "delimiter"]
+      ],
+      rulevalue: [
+        { include: "@comments" },
+        { include: "@strings" },
+        { include: "@term" },
+        ["!important", "keyword"],
+        [";", "delimiter", "@pop"],
+        ["(?=})", { token: "", next: "@pop" }]
+      ],
+      warndebug: [["[@](warn|debug)", { token: "keyword", next: "@declarationbody" }]],
+      import: [["[@](import)", { token: "keyword", next: "@declarationbody" }]],
+      urldeclaration: [
+        { include: "@strings" },
+        ["[^)\r\n]+", "string"],
+        ["\\)", { token: "delimiter.parenthesis", next: "@pop" }]
+      ],
+      parenthizedterm: [
+        { include: "@term" },
+        ["\\)", { token: "delimiter.parenthesis", next: "@pop" }]
+      ],
+      declarationbody: [
+        { include: "@term" },
+        [";", "delimiter", "@pop"],
+        ["(?=})", { token: "", next: "@pop" }]
+      ],
+      comments: [
+        ["\\/\\*", "comment", "@comment"],
+        ["\\/\\/+.*", "comment"]
+      ],
+      comment: [
+        ["\\*\\/", "comment", "@pop"],
+        [/[^*/]+/, "comment"],
+        [/./, "comment"]
+      ],
+      name: [["@identifier", "attribute.value"]],
+      numbers: [
+        ["-?(\\d*\\.)?\\d+([eE][\\-+]?\\d+)?", { token: "attribute.value.number", next: "@units" }],
+        ["#[0-9a-fA-F_]+(?!\\w)", "attribute.value.hex"]
+      ],
+      units: [
+        [
+          "(em|ex|ch|rem|vmin|vmax|vw|vh|vm|cm|mm|in|px|pt|pc|deg|grad|rad|turn|s|ms|Hz|kHz|%)?",
+          "attribute.value.unit",
+          "@pop"
+        ]
+      ],
+      keyframedeclaration: [
+        ["@identifier", "attribute.value"],
+        ["{", { token: "delimiter.bracket", switchTo: "@keyframebody" }]
+      ],
+      keyframebody: [
+        { include: "@term" },
+        ["{", { token: "delimiter.bracket", next: "@selectorbody" }],
+        ["}", { token: "delimiter.bracket", next: "@pop" }]
+      ],
+      functioninvocation: [
+        ["@identifier\\(", { token: "attribute.value", next: "@functionarguments" }]
+      ],
+      functionarguments: [
+        ["\\$@identifier@ws:", "attribute.name"],
+        ["[,]", "delimiter"],
+        { include: "@term" },
+        ["\\)", { token: "attribute.value", next: "@pop" }]
+      ],
+      strings: [
+        ['~?"', { token: "string", next: "@stringenddoublequote" }],
+        ["~?'", { token: "string", next: "@stringendquote" }]
+      ],
+      stringenddoublequote: [
+        ["\\\\.", "string"],
+        ['"', { token: "string", next: "@pop" }],
+        [/[^\\"]+/, "string"],
+        [".", "string"]
+      ],
+      stringendquote: [
+        ["\\\\.", "string"],
+        ["'", { token: "string", next: "@pop" }],
+        [/[^\\']+/, "string"],
+        [".", "string"]
+      ]
+    }
+  };
+  return css_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/dart/dart.js

@@ -0,0 +1,287 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/dart/dart",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/dart/dart.ts
+  var dart_exports = {};
+  __export(dart_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "'", close: "'", notIn: ["string", "comment"] },
+      { open: '"', close: '"', notIn: ["string"] },
+      { open: "`", close: "`", notIn: ["string", "comment"] },
+      { open: "/**", close: " */", notIn: ["string"] }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "<", close: ">" },
+      { open: "'", close: "'" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "`", close: "`" }
+    ],
+    folding: {
+      markers: {
+        start: /^\s*\s*#?region\b/,
+        end: /^\s*\s*#?endregion\b/
+      }
+    }
+  };
+  var language = {
+    defaultToken: "invalid",
+    tokenPostfix: ".dart",
+    keywords: [
+      "abstract",
+      "dynamic",
+      "implements",
+      "show",
+      "as",
+      "else",
+      "import",
+      "static",
+      "assert",
+      "enum",
+      "in",
+      "super",
+      "async",
+      "export",
+      "interface",
+      "switch",
+      "await",
+      "extends",
+      "is",
+      "sync",
+      "break",
+      "external",
+      "library",
+      "this",
+      "case",
+      "factory",
+      "mixin",
+      "throw",
+      "catch",
+      "false",
+      "new",
+      "true",
+      "class",
+      "final",
+      "null",
+      "try",
+      "const",
+      "finally",
+      "on",
+      "typedef",
+      "continue",
+      "for",
+      "operator",
+      "var",
+      "covariant",
+      "Function",
+      "part",
+      "void",
+      "default",
+      "get",
+      "rethrow",
+      "while",
+      "deferred",
+      "hide",
+      "return",
+      "with",
+      "do",
+      "if",
+      "set",
+      "yield"
+    ],
+    typeKeywords: ["int", "double", "String", "bool"],
+    operators: [
+      "+",
+      "-",
+      "*",
+      "/",
+      "~/",
+      "%",
+      "++",
+      "--",
+      "==",
+      "!=",
+      ">",
+      "<",
+      ">=",
+      "<=",
+      "=",
+      "-=",
+      "/=",
+      "%=",
+      ">>=",
+      "^=",
+      "+=",
+      "*=",
+      "~/=",
+      "<<=",
+      "&=",
+      "!=",
+      "||",
+      "&&",
+      "&",
+      "|",
+      "^",
+      "~",
+      "<<",
+      ">>",
+      "!",
+      ">>>",
+      "??",
+      "?",
+      ":",
+      "|="
+    ],
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    digits: /\d+(_+\d+)*/,
+    octaldigits: /[0-7]+(_+[0-7]+)*/,
+    binarydigits: /[0-1]+(_+[0-1]+)*/,
+    hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+    regexpctl: /[(){}\[\]\$\^|\-*+?\.]/,
+    regexpesc: /\\(?:[bBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})/,
+    tokenizer: {
+      root: [[/[{}]/, "delimiter.bracket"], { include: "common" }],
+      common: [
+        [
+          /[a-z_$][\w$]*/,
+          {
+            cases: {
+              "@typeKeywords": "type.identifier",
+              "@keywords": "keyword",
+              "@default": "identifier"
+            }
+          }
+        ],
+        [/[A-Z_$][\w\$]*/, "type.identifier"],
+        { include: "@whitespace" },
+        [
+          /\/(?=([^\\\/]|\\.)+\/([gimsuy]*)(\s*)(\.|;|,|\)|\]|\}|$))/,
+          { token: "regexp", bracket: "@open", next: "@regexp" }
+        ],
+        [/@[a-zA-Z]+/, "annotation"],
+        [/[()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [/!(?=([^=]|$))/, "delimiter"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "delimiter",
+              "@default": ""
+            }
+          }
+        ],
+        [/(@digits)[eE]([\-+]?(@digits))?/, "number.float"],
+        [/(@digits)\.(@digits)([eE][\-+]?(@digits))?/, "number.float"],
+        [/0[xX](@hexdigits)n?/, "number.hex"],
+        [/0[oO]?(@octaldigits)n?/, "number.octal"],
+        [/0[bB](@binarydigits)n?/, "number.binary"],
+        [/(@digits)n?/, "number"],
+        [/[;,.]/, "delimiter"],
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        [/'([^'\\]|\\.)*$/, "string.invalid"],
+        [/"/, "string", "@string_double"],
+        [/'/, "string", "@string_single"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/\/\*\*(?!\/)/, "comment.doc", "@jsdoc"],
+        [/\/\*/, "comment", "@comment"],
+        [/\/\/\/.*$/, "comment.doc"],
+        [/\/\/.*$/, "comment"]
+      ],
+      comment: [
+        [/[^\/*]+/, "comment"],
+        [/\*\//, "comment", "@pop"],
+        [/[\/*]/, "comment"]
+      ],
+      jsdoc: [
+        [/[^\/*]+/, "comment.doc"],
+        [/\*\//, "comment.doc", "@pop"],
+        [/[\/*]/, "comment.doc"]
+      ],
+      regexp: [
+        [
+          /(\{)(\d+(?:,\d*)?)(\})/,
+          ["regexp.escape.control", "regexp.escape.control", "regexp.escape.control"]
+        ],
+        [
+          /(\[)(\^?)(?=(?:[^\]\\\/]|\\.)+)/,
+          ["regexp.escape.control", { token: "regexp.escape.control", next: "@regexrange" }]
+        ],
+        [/(\()(\?:|\?=|\?!)/, ["regexp.escape.control", "regexp.escape.control"]],
+        [/[()]/, "regexp.escape.control"],
+        [/@regexpctl/, "regexp.escape.control"],
+        [/[^\\\/]/, "regexp"],
+        [/@regexpesc/, "regexp.escape"],
+        [/\\\./, "regexp.invalid"],
+        [/(\/)([gimsuy]*)/, [{ token: "regexp", bracket: "@close", next: "@pop" }, "keyword.other"]]
+      ],
+      regexrange: [
+        [/-/, "regexp.escape.control"],
+        [/\^/, "regexp.invalid"],
+        [/@regexpesc/, "regexp.escape"],
+        [/[^\]]/, "regexp"],
+        [
+          /\]/,
+          {
+            token: "regexp.escape.control",
+            next: "@pop",
+            bracket: "@close"
+          }
+        ]
+      ],
+      string_double: [
+        [/[^\\"\$]+/, "string"],
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, "string", "@pop"],
+        [/\$\w+/, "identifier"]
+      ],
+      string_single: [
+        [/[^\\'\$]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/'/, "string", "@pop"],
+        [/\$\w+/, "identifier"]
+      ]
+    }
+  };
+  return dart_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/dockerfile/dockerfile.js

@@ -0,0 +1,149 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/dockerfile/dockerfile",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/dockerfile/dockerfile.ts
+  var dockerfile_exports = {};
+  __export(dockerfile_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".dockerfile",
+    variable: /\${?[\w]+}?/,
+    tokenizer: {
+      root: [
+        { include: "@whitespace" },
+        { include: "@comment" },
+        [/(ONBUILD)(\s+)/, ["keyword", ""]],
+        [/(ENV)(\s+)([\w]+)/, ["keyword", "", { token: "variable", next: "@arguments" }]],
+        [
+          /(FROM|MAINTAINER|RUN|EXPOSE|ENV|ADD|ARG|VOLUME|LABEL|USER|WORKDIR|COPY|CMD|STOPSIGNAL|SHELL|HEALTHCHECK|ENTRYPOINT)/,
+          { token: "keyword", next: "@arguments" }
+        ]
+      ],
+      arguments: [
+        { include: "@whitespace" },
+        { include: "@strings" },
+        [
+          /(@variable)/,
+          {
+            cases: {
+              "@eos": { token: "variable", next: "@popall" },
+              "@default": "variable"
+            }
+          }
+        ],
+        [
+          /\\/,
+          {
+            cases: {
+              "@eos": "",
+              "@default": ""
+            }
+          }
+        ],
+        [
+          /./,
+          {
+            cases: {
+              "@eos": { token: "", next: "@popall" },
+              "@default": ""
+            }
+          }
+        ]
+      ],
+      whitespace: [
+        [
+          /\s+/,
+          {
+            cases: {
+              "@eos": { token: "", next: "@popall" },
+              "@default": ""
+            }
+          }
+        ]
+      ],
+      comment: [[/(^#.*$)/, "comment", "@popall"]],
+      strings: [
+        [/\\'$/, "", "@popall"],
+        [/\\'/, ""],
+        [/'$/, "string", "@popall"],
+        [/'/, "string", "@stringBody"],
+        [/"$/, "string", "@popall"],
+        [/"/, "string", "@dblStringBody"]
+      ],
+      stringBody: [
+        [
+          /[^\\\$']/,
+          {
+            cases: {
+              "@eos": { token: "string", next: "@popall" },
+              "@default": "string"
+            }
+          }
+        ],
+        [/\\./, "string.escape"],
+        [/'$/, "string", "@popall"],
+        [/'/, "string", "@pop"],
+        [/(@variable)/, "variable"],
+        [/\\$/, "string"],
+        [/$/, "string", "@popall"]
+      ],
+      dblStringBody: [
+        [
+          /[^\\\$"]/,
+          {
+            cases: {
+              "@eos": { token: "string", next: "@popall" },
+              "@default": "string"
+            }
+          }
+        ],
+        [/\\./, "string.escape"],
+        [/"$/, "string", "@popall"],
+        [/"/, "string", "@pop"],
+        [/(@variable)/, "variable"],
+        [/\\$/, "string"],
+        [/$/, "string", "@popall"]
+      ]
+    }
+  };
+  return dockerfile_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/ecl/ecl.js

@@ -0,0 +1,471 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/ecl/ecl",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/ecl/ecl.ts
+  var ecl_exports = {};
+  __export(ecl_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "'", close: "'", notIn: ["string", "comment"] },
+      { open: '"', close: '"', notIn: ["string", "comment"] }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "<", close: ">" },
+      { open: "'", close: "'" },
+      { open: '"', close: '"' }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".ecl",
+    ignoreCase: true,
+    brackets: [
+      { open: "{", close: "}", token: "delimiter.curly" },
+      { open: "[", close: "]", token: "delimiter.square" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" },
+      { open: "<", close: ">", token: "delimiter.angle" }
+    ],
+    pounds: [
+      "append",
+      "break",
+      "declare",
+      "demangle",
+      "end",
+      "for",
+      "getdatatype",
+      "if",
+      "inmodule",
+      "loop",
+      "mangle",
+      "onwarning",
+      "option",
+      "set",
+      "stored",
+      "uniquename"
+    ].join("|"),
+    keywords: [
+      "__compressed__",
+      "after",
+      "all",
+      "and",
+      "any",
+      "as",
+      "atmost",
+      "before",
+      "beginc",
+      "best",
+      "between",
+      "case",
+      "cluster",
+      "compressed",
+      "compression",
+      "const",
+      "counter",
+      "csv",
+      "default",
+      "descend",
+      "embed",
+      "encoding",
+      "encrypt",
+      "end",
+      "endc",
+      "endembed",
+      "endmacro",
+      "enum",
+      "escape",
+      "except",
+      "exclusive",
+      "expire",
+      "export",
+      "extend",
+      "fail",
+      "few",
+      "fileposition",
+      "first",
+      "flat",
+      "forward",
+      "from",
+      "full",
+      "function",
+      "functionmacro",
+      "group",
+      "grouped",
+      "heading",
+      "hole",
+      "ifblock",
+      "import",
+      "in",
+      "inner",
+      "interface",
+      "internal",
+      "joined",
+      "keep",
+      "keyed",
+      "last",
+      "left",
+      "limit",
+      "linkcounted",
+      "literal",
+      "little_endian",
+      "load",
+      "local",
+      "locale",
+      "lookup",
+      "lzw",
+      "macro",
+      "many",
+      "maxcount",
+      "maxlength",
+      "min skew",
+      "module",
+      "mofn",
+      "multiple",
+      "named",
+      "namespace",
+      "nocase",
+      "noroot",
+      "noscan",
+      "nosort",
+      "not",
+      "noxpath",
+      "of",
+      "onfail",
+      "only",
+      "opt",
+      "or",
+      "outer",
+      "overwrite",
+      "packed",
+      "partition",
+      "penalty",
+      "physicallength",
+      "pipe",
+      "prefetch",
+      "quote",
+      "record",
+      "repeat",
+      "retry",
+      "return",
+      "right",
+      "right1",
+      "right2",
+      "rows",
+      "rowset",
+      "scan",
+      "scope",
+      "self",
+      "separator",
+      "service",
+      "shared",
+      "skew",
+      "skip",
+      "smart",
+      "soapaction",
+      "sql",
+      "stable",
+      "store",
+      "terminator",
+      "thor",
+      "threshold",
+      "timelimit",
+      "timeout",
+      "token",
+      "transform",
+      "trim",
+      "type",
+      "unicodeorder",
+      "unordered",
+      "unsorted",
+      "unstable",
+      "update",
+      "use",
+      "validate",
+      "virtual",
+      "whole",
+      "width",
+      "wild",
+      "within",
+      "wnotrim",
+      "xml",
+      "xpath"
+    ],
+    functions: [
+      "abs",
+      "acos",
+      "aggregate",
+      "allnodes",
+      "apply",
+      "ascii",
+      "asin",
+      "assert",
+      "asstring",
+      "atan",
+      "atan2",
+      "ave",
+      "build",
+      "buildindex",
+      "case",
+      "catch",
+      "choose",
+      "choosen",
+      "choosesets",
+      "clustersize",
+      "combine",
+      "correlation",
+      "cos",
+      "cosh",
+      "count",
+      "covariance",
+      "cron",
+      "dataset",
+      "dedup",
+      "define",
+      "denormalize",
+      "dictionary",
+      "distribute",
+      "distributed",
+      "distribution",
+      "ebcdic",
+      "enth",
+      "error",
+      "evaluate",
+      "event",
+      "eventextra",
+      "eventname",
+      "exists",
+      "exp",
+      "fail",
+      "failcode",
+      "failmessage",
+      "fetch",
+      "fromunicode",
+      "fromxml",
+      "getenv",
+      "getisvalid",
+      "global",
+      "graph",
+      "group",
+      "hash",
+      "hash32",
+      "hash64",
+      "hashcrc",
+      "hashmd5",
+      "having",
+      "httpcall",
+      "httpheader",
+      "if",
+      "iff",
+      "index",
+      "intformat",
+      "isvalid",
+      "iterate",
+      "join",
+      "keydiff",
+      "keypatch",
+      "keyunicode",
+      "length",
+      "library",
+      "limit",
+      "ln",
+      "loadxml",
+      "local",
+      "log",
+      "loop",
+      "map",
+      "matched",
+      "matchlength",
+      "matchposition",
+      "matchtext",
+      "matchunicode",
+      "max",
+      "merge",
+      "mergejoin",
+      "min",
+      "nofold",
+      "nolocal",
+      "nonempty",
+      "normalize",
+      "nothor",
+      "notify",
+      "output",
+      "parallel",
+      "parse",
+      "pipe",
+      "power",
+      "preload",
+      "process",
+      "project",
+      "pull",
+      "random",
+      "range",
+      "rank",
+      "ranked",
+      "realformat",
+      "recordof",
+      "regexfind",
+      "regexreplace",
+      "regroup",
+      "rejected",
+      "rollup",
+      "round",
+      "roundup",
+      "row",
+      "rowdiff",
+      "sample",
+      "sequential",
+      "set",
+      "sin",
+      "sinh",
+      "sizeof",
+      "soapcall",
+      "sort",
+      "sorted",
+      "sqrt",
+      "stepped",
+      "stored",
+      "sum",
+      "table",
+      "tan",
+      "tanh",
+      "thisnode",
+      "topn",
+      "tounicode",
+      "toxml",
+      "transfer",
+      "transform",
+      "trim",
+      "truncate",
+      "typeof",
+      "ungroup",
+      "unicodeorder",
+      "variance",
+      "wait",
+      "which",
+      "workunit",
+      "xmldecode",
+      "xmlencode",
+      "xmltext",
+      "xmlunicode"
+    ],
+    typesint: ["integer", "unsigned"].join("|"),
+    typesnum: ["data", "qstring", "string", "unicode", "utf8", "varstring", "varunicode"],
+    typesone: [
+      "ascii",
+      "big_endian",
+      "boolean",
+      "data",
+      "decimal",
+      "ebcdic",
+      "grouped",
+      "integer",
+      "linkcounted",
+      "pattern",
+      "qstring",
+      "real",
+      "record",
+      "rule",
+      "set of",
+      "streamed",
+      "string",
+      "token",
+      "udecimal",
+      "unicode",
+      "unsigned",
+      "utf8",
+      "varstring",
+      "varunicode"
+    ].join("|"),
+    operators: ["+", "-", "/", ":=", "<", "<>", "=", ">", "\\", "and", "in", "not", "or"],
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    tokenizer: {
+      root: [
+        [/@typesint[4|8]/, "type"],
+        [/#(@pounds)/, "type"],
+        [/@typesone/, "type"],
+        [
+          /[a-zA-Z_$][\w-$]*/,
+          {
+            cases: {
+              "@functions": "keyword.function",
+              "@keywords": "keyword",
+              "@operators": "operator"
+            }
+          }
+        ],
+        { include: "@whitespace" },
+        [/[{}()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "delimiter",
+              "@default": ""
+            }
+          }
+        ],
+        [/[0-9_]*\.[0-9_]+([eE][\-+]?\d+)?/, "number.float"],
+        [/0[xX][0-9a-fA-F_]+/, "number.hex"],
+        [/0[bB][01]+/, "number.hex"],
+        [/[0-9_]+/, "number"],
+        [/[;,.]/, "delimiter"],
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        [/"/, "string", "@string"],
+        [/'[^\\']'/, "string"],
+        [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+        [/'/, "string.invalid"]
+      ],
+      whitespace: [
+        [/[ \t\v\f\r\n]+/, ""],
+        [/\/\*/, "comment", "@comment"],
+        [/\/\/.*$/, "comment"]
+      ],
+      comment: [
+        [/[^\/*]+/, "comment"],
+        [/\*\//, "comment", "@pop"],
+        [/[\/*]/, "comment"]
+      ],
+      string: [
+        [/[^\\']+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/'/, "string", "@pop"]
+      ]
+    }
+  };
+  return ecl_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/elixir/elixir.js

@@ -0,0 +1,484 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/elixir/elixir",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/elixir/elixir.ts
+  var elixir_exports = {};
+  __export(elixir_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "#"
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "'", close: "'" },
+      { open: '"', close: '"' }
+    ],
+    autoClosingPairs: [
+      { open: "'", close: "'", notIn: ["string", "comment"] },
+      { open: '"', close: '"', notIn: ["comment"] },
+      { open: '"""', close: '"""' },
+      { open: "`", close: "`", notIn: ["string", "comment"] },
+      { open: "(", close: ")" },
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "<<", close: ">>" }
+    ],
+    indentationRules: {
+      increaseIndentPattern: /^\s*(after|else|catch|rescue|fn|[^#]*(do|<\-|\->|\{|\[|\=))\s*$/,
+      decreaseIndentPattern: /^\s*((\}|\])\s*$|(after|else|catch|rescue|end)\b)/
+    }
+  };
+  var language = {
+    defaultToken: "source",
+    tokenPostfix: ".elixir",
+    brackets: [
+      { open: "[", close: "]", token: "delimiter.square" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" },
+      { open: "{", close: "}", token: "delimiter.curly" },
+      { open: "<<", close: ">>", token: "delimiter.angle.special" }
+    ],
+    declarationKeywords: [
+      "def",
+      "defp",
+      "defn",
+      "defnp",
+      "defguard",
+      "defguardp",
+      "defmacro",
+      "defmacrop",
+      "defdelegate",
+      "defcallback",
+      "defmacrocallback",
+      "defmodule",
+      "defprotocol",
+      "defexception",
+      "defimpl",
+      "defstruct"
+    ],
+    operatorKeywords: ["and", "in", "not", "or", "when"],
+    namespaceKeywords: ["alias", "import", "require", "use"],
+    otherKeywords: [
+      "after",
+      "case",
+      "catch",
+      "cond",
+      "do",
+      "else",
+      "end",
+      "fn",
+      "for",
+      "if",
+      "quote",
+      "raise",
+      "receive",
+      "rescue",
+      "super",
+      "throw",
+      "try",
+      "unless",
+      "unquote_splicing",
+      "unquote",
+      "with"
+    ],
+    constants: ["true", "false", "nil"],
+    nameBuiltin: ["__MODULE__", "__DIR__", "__ENV__", "__CALLER__", "__STACKTRACE__"],
+    operator: /-[->]?|!={0,2}|\*{1,2}|\/|\\\\|&{1,3}|\.\.?|\^(?:\^\^)?|\+\+?|<(?:-|<<|=|>|\|>|~>?)?|=~|={1,3}|>(?:=|>>)?|\|~>|\|>|\|{1,3}|~>>?|~~~|::/,
+    variableName: /[a-z_][a-zA-Z0-9_]*[?!]?/,
+    atomName: /[a-zA-Z_][a-zA-Z0-9_@]*[?!]?|@specialAtomName|@operator/,
+    specialAtomName: /\.\.\.|<<>>|%\{\}|%|\{\}/,
+    aliasPart: /[A-Z][a-zA-Z0-9_]*/,
+    moduleName: /@aliasPart(?:\.@aliasPart)*/,
+    sigilSymmetricDelimiter: /"""|'''|"|'|\/|\|/,
+    sigilStartDelimiter: /@sigilSymmetricDelimiter|<|\{|\[|\(/,
+    sigilEndDelimiter: /@sigilSymmetricDelimiter|>|\}|\]|\)/,
+    sigilModifiers: /[a-zA-Z0-9]*/,
+    decimal: /\d(?:_?\d)*/,
+    hex: /[0-9a-fA-F](_?[0-9a-fA-F])*/,
+    octal: /[0-7](_?[0-7])*/,
+    binary: /[01](_?[01])*/,
+    escape: /\\u[0-9a-fA-F]{4}|\\x[0-9a-fA-F]{2}|\\./,
+    tokenizer: {
+      root: [
+        { include: "@whitespace" },
+        { include: "@comments" },
+        { include: "@keywordsShorthand" },
+        { include: "@numbers" },
+        { include: "@identifiers" },
+        { include: "@strings" },
+        { include: "@atoms" },
+        { include: "@sigils" },
+        { include: "@attributes" },
+        { include: "@symbols" }
+      ],
+      whitespace: [[/\s+/, "white"]],
+      comments: [[/(#)(.*)/, ["comment.punctuation", "comment"]]],
+      keywordsShorthand: [
+        [/(@atomName)(:)/, ["constant", "constant.punctuation"]],
+        [
+          /"(?=([^"]|#\{.*?\}|\\")*":)/,
+          { token: "constant.delimiter", next: "@doubleQuotedStringKeyword" }
+        ],
+        [
+          /'(?=([^']|#\{.*?\}|\\')*':)/,
+          { token: "constant.delimiter", next: "@singleQuotedStringKeyword" }
+        ]
+      ],
+      doubleQuotedStringKeyword: [
+        [/":/, { token: "constant.delimiter", next: "@pop" }],
+        { include: "@stringConstantContentInterpol" }
+      ],
+      singleQuotedStringKeyword: [
+        [/':/, { token: "constant.delimiter", next: "@pop" }],
+        { include: "@stringConstantContentInterpol" }
+      ],
+      numbers: [
+        [/0b@binary/, "number.binary"],
+        [/0o@octal/, "number.octal"],
+        [/0x@hex/, "number.hex"],
+        [/@decimal\.@decimal([eE]-?@decimal)?/, "number.float"],
+        [/@decimal/, "number"]
+      ],
+      identifiers: [
+        [
+          /\b(defp?|defnp?|defmacrop?|defguardp?|defdelegate)(\s+)(@variableName)(?!\s+@operator)/,
+          [
+            "keyword.declaration",
+            "white",
+            {
+              cases: {
+                unquote: "keyword",
+                "@default": "function"
+              }
+            }
+          ]
+        ],
+        [
+          /(@variableName)(?=\s*\.?\s*\()/,
+          {
+            cases: {
+              "@declarationKeywords": "keyword.declaration",
+              "@namespaceKeywords": "keyword",
+              "@otherKeywords": "keyword",
+              "@default": "function.call"
+            }
+          }
+        ],
+        [
+          /(@moduleName)(\s*)(\.)(\s*)(@variableName)/,
+          ["type.identifier", "white", "operator", "white", "function.call"]
+        ],
+        [
+          /(:)(@atomName)(\s*)(\.)(\s*)(@variableName)/,
+          ["constant.punctuation", "constant", "white", "operator", "white", "function.call"]
+        ],
+        [
+          /(\|>)(\s*)(@variableName)/,
+          [
+            "operator",
+            "white",
+            {
+              cases: {
+                "@otherKeywords": "keyword",
+                "@default": "function.call"
+              }
+            }
+          ]
+        ],
+        [
+          /(&)(\s*)(@variableName)/,
+          ["operator", "white", "function.call"]
+        ],
+        [
+          /@variableName/,
+          {
+            cases: {
+              "@declarationKeywords": "keyword.declaration",
+              "@operatorKeywords": "keyword.operator",
+              "@namespaceKeywords": "keyword",
+              "@otherKeywords": "keyword",
+              "@constants": "constant.language",
+              "@nameBuiltin": "variable.language",
+              "_.*": "comment.unused",
+              "@default": "identifier"
+            }
+          }
+        ],
+        [/@moduleName/, "type.identifier"]
+      ],
+      strings: [
+        [/"""/, { token: "string.delimiter", next: "@doubleQuotedHeredoc" }],
+        [/'''/, { token: "string.delimiter", next: "@singleQuotedHeredoc" }],
+        [/"/, { token: "string.delimiter", next: "@doubleQuotedString" }],
+        [/'/, { token: "string.delimiter", next: "@singleQuotedString" }]
+      ],
+      doubleQuotedHeredoc: [
+        [/"""/, { token: "string.delimiter", next: "@pop" }],
+        { include: "@stringContentInterpol" }
+      ],
+      singleQuotedHeredoc: [
+        [/'''/, { token: "string.delimiter", next: "@pop" }],
+        { include: "@stringContentInterpol" }
+      ],
+      doubleQuotedString: [
+        [/"/, { token: "string.delimiter", next: "@pop" }],
+        { include: "@stringContentInterpol" }
+      ],
+      singleQuotedString: [
+        [/'/, { token: "string.delimiter", next: "@pop" }],
+        { include: "@stringContentInterpol" }
+      ],
+      atoms: [
+        [/(:)(@atomName)/, ["constant.punctuation", "constant"]],
+        [/:"/, { token: "constant.delimiter", next: "@doubleQuotedStringAtom" }],
+        [/:'/, { token: "constant.delimiter", next: "@singleQuotedStringAtom" }]
+      ],
+      doubleQuotedStringAtom: [
+        [/"/, { token: "constant.delimiter", next: "@pop" }],
+        { include: "@stringConstantContentInterpol" }
+      ],
+      singleQuotedStringAtom: [
+        [/'/, { token: "constant.delimiter", next: "@pop" }],
+        { include: "@stringConstantContentInterpol" }
+      ],
+      sigils: [
+        [/~[a-z]@sigilStartDelimiter/, { token: "@rematch", next: "@sigil.interpol" }],
+        [/~[A-Z]@sigilStartDelimiter/, { token: "@rematch", next: "@sigil.noInterpol" }]
+      ],
+      sigil: [
+        [/~([a-zA-Z])\{/, { token: "@rematch", switchTo: "@sigilStart.$S2.$1.{.}" }],
+        [/~([a-zA-Z])\[/, { token: "@rematch", switchTo: "@sigilStart.$S2.$1.[.]" }],
+        [/~([a-zA-Z])\(/, { token: "@rematch", switchTo: "@sigilStart.$S2.$1.(.)" }],
+        [/~([a-zA-Z])\</, { token: "@rematch", switchTo: "@sigilStart.$S2.$1.<.>" }],
+        [
+          /~([a-zA-Z])(@sigilSymmetricDelimiter)/,
+          { token: "@rematch", switchTo: "@sigilStart.$S2.$1.$2.$2" }
+        ]
+      ],
+      "sigilStart.interpol.s": [
+        [
+          /~s@sigilStartDelimiter/,
+          {
+            token: "string.delimiter",
+            switchTo: "@sigilContinue.$S2.$S3.$S4.$S5"
+          }
+        ]
+      ],
+      "sigilContinue.interpol.s": [
+        [
+          /(@sigilEndDelimiter)@sigilModifiers/,
+          {
+            cases: {
+              "$1==$S5": { token: "string.delimiter", next: "@pop" },
+              "@default": "string"
+            }
+          }
+        ],
+        { include: "@stringContentInterpol" }
+      ],
+      "sigilStart.noInterpol.S": [
+        [
+          /~S@sigilStartDelimiter/,
+          {
+            token: "string.delimiter",
+            switchTo: "@sigilContinue.$S2.$S3.$S4.$S5"
+          }
+        ]
+      ],
+      "sigilContinue.noInterpol.S": [
+        [/(^|[^\\])\\@sigilEndDelimiter/, "string"],
+        [
+          /(@sigilEndDelimiter)@sigilModifiers/,
+          {
+            cases: {
+              "$1==$S5": { token: "string.delimiter", next: "@pop" },
+              "@default": "string"
+            }
+          }
+        ],
+        { include: "@stringContent" }
+      ],
+      "sigilStart.interpol.r": [
+        [
+          /~r@sigilStartDelimiter/,
+          {
+            token: "regexp.delimiter",
+            switchTo: "@sigilContinue.$S2.$S3.$S4.$S5"
+          }
+        ]
+      ],
+      "sigilContinue.interpol.r": [
+        [
+          /(@sigilEndDelimiter)@sigilModifiers/,
+          {
+            cases: {
+              "$1==$S5": { token: "regexp.delimiter", next: "@pop" },
+              "@default": "regexp"
+            }
+          }
+        ],
+        { include: "@regexpContentInterpol" }
+      ],
+      "sigilStart.noInterpol.R": [
+        [
+          /~R@sigilStartDelimiter/,
+          {
+            token: "regexp.delimiter",
+            switchTo: "@sigilContinue.$S2.$S3.$S4.$S5"
+          }
+        ]
+      ],
+      "sigilContinue.noInterpol.R": [
+        [/(^|[^\\])\\@sigilEndDelimiter/, "regexp"],
+        [
+          /(@sigilEndDelimiter)@sigilModifiers/,
+          {
+            cases: {
+              "$1==$S5": { token: "regexp.delimiter", next: "@pop" },
+              "@default": "regexp"
+            }
+          }
+        ],
+        { include: "@regexpContent" }
+      ],
+      "sigilStart.interpol": [
+        [
+          /~([a-zA-Z])@sigilStartDelimiter/,
+          {
+            token: "sigil.delimiter",
+            switchTo: "@sigilContinue.$S2.$S3.$S4.$S5"
+          }
+        ]
+      ],
+      "sigilContinue.interpol": [
+        [
+          /(@sigilEndDelimiter)@sigilModifiers/,
+          {
+            cases: {
+              "$1==$S5": { token: "sigil.delimiter", next: "@pop" },
+              "@default": "sigil"
+            }
+          }
+        ],
+        { include: "@sigilContentInterpol" }
+      ],
+      "sigilStart.noInterpol": [
+        [
+          /~([a-zA-Z])@sigilStartDelimiter/,
+          {
+            token: "sigil.delimiter",
+            switchTo: "@sigilContinue.$S2.$S3.$S4.$S5"
+          }
+        ]
+      ],
+      "sigilContinue.noInterpol": [
+        [/(^|[^\\])\\@sigilEndDelimiter/, "sigil"],
+        [
+          /(@sigilEndDelimiter)@sigilModifiers/,
+          {
+            cases: {
+              "$1==$S5": { token: "sigil.delimiter", next: "@pop" },
+              "@default": "sigil"
+            }
+          }
+        ],
+        { include: "@sigilContent" }
+      ],
+      attributes: [
+        [
+          /\@(module|type)?doc (~[sS])?"""/,
+          {
+            token: "comment.block.documentation",
+            next: "@doubleQuotedHeredocDocstring"
+          }
+        ],
+        [
+          /\@(module|type)?doc (~[sS])?"/,
+          {
+            token: "comment.block.documentation",
+            next: "@doubleQuotedStringDocstring"
+          }
+        ],
+        [/\@(module|type)?doc false/, "comment.block.documentation"],
+        [/\@(@variableName)/, "variable"]
+      ],
+      doubleQuotedHeredocDocstring: [
+        [/"""/, { token: "comment.block.documentation", next: "@pop" }],
+        { include: "@docstringContent" }
+      ],
+      doubleQuotedStringDocstring: [
+        [/"/, { token: "comment.block.documentation", next: "@pop" }],
+        { include: "@docstringContent" }
+      ],
+      symbols: [
+        [/\?(\\.|[^\\\s])/, "number.constant"],
+        [/&\d+/, "operator"],
+        [/<<<|>>>/, "operator"],
+        [/[()\[\]\{\}]|<<|>>/, "@brackets"],
+        [/\.\.\./, "identifier"],
+        [/=>/, "punctuation"],
+        [/@operator/, "operator"],
+        [/[:;,.%]/, "punctuation"]
+      ],
+      stringContentInterpol: [
+        { include: "@interpolation" },
+        { include: "@escapeChar" },
+        { include: "@stringContent" }
+      ],
+      stringContent: [[/./, "string"]],
+      stringConstantContentInterpol: [
+        { include: "@interpolation" },
+        { include: "@escapeChar" },
+        { include: "@stringConstantContent" }
+      ],
+      stringConstantContent: [[/./, "constant"]],
+      regexpContentInterpol: [
+        { include: "@interpolation" },
+        { include: "@escapeChar" },
+        { include: "@regexpContent" }
+      ],
+      regexpContent: [
+        [/(\s)(#)(\s.*)$/, ["white", "comment.punctuation", "comment"]],
+        [/./, "regexp"]
+      ],
+      sigilContentInterpol: [
+        { include: "@interpolation" },
+        { include: "@escapeChar" },
+        { include: "@sigilContent" }
+      ],
+      sigilContent: [[/./, "sigil"]],
+      docstringContent: [[/./, "comment.block.documentation"]],
+      escapeChar: [[/@escape/, "constant.character.escape"]],
+      interpolation: [[/#{/, { token: "delimiter.bracket.embed", next: "@interpolationContinue" }]],
+      interpolationContinue: [
+        [/}/, { token: "delimiter.bracket.embed", next: "@pop" }],
+        { include: "@root" }
+      ]
+    }
+  };
+  return elixir_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/flow9/flow9.js

@@ -0,0 +1,158 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/flow9/flow9",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/flow9/flow9.ts
+  var flow9_exports = {};
+  __export(flow9_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      blockComment: ["/*", "*/"],
+      lineComment: "//"
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}", notIn: ["string"] },
+      { open: "[", close: "]", notIn: ["string"] },
+      { open: "(", close: ")", notIn: ["string"] },
+      { open: '"', close: '"', notIn: ["string"] },
+      { open: "'", close: "'", notIn: ["string"] }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: "<", close: ">" }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".flow",
+    keywords: [
+      "import",
+      "require",
+      "export",
+      "forbid",
+      "native",
+      "if",
+      "else",
+      "cast",
+      "unsafe",
+      "switch",
+      "default"
+    ],
+    types: [
+      "io",
+      "mutable",
+      "bool",
+      "int",
+      "double",
+      "string",
+      "flow",
+      "void",
+      "ref",
+      "true",
+      "false",
+      "with"
+    ],
+    operators: [
+      "=",
+      ">",
+      "<",
+      "<=",
+      ">=",
+      "==",
+      "!",
+      "!=",
+      ":=",
+      "::=",
+      "&&",
+      "||",
+      "+",
+      "-",
+      "*",
+      "/",
+      "@",
+      "&",
+      "%",
+      ":",
+      "->",
+      "\\",
+      "$",
+      "??",
+      "^"
+    ],
+    symbols: /[@$=><!~?:&|+\-*\\\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    tokenizer: {
+      root: [
+        [
+          /[a-zA-Z_]\w*/,
+          {
+            cases: {
+              "@keywords": "keyword",
+              "@types": "type",
+              "@default": "identifier"
+            }
+          }
+        ],
+        { include: "@whitespace" },
+        [/[{}()\[\]]/, "delimiter"],
+        [/[<>](?!@symbols)/, "delimiter"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "delimiter",
+              "@default": ""
+            }
+          }
+        ],
+        [/((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)/, "number"],
+        [/[;,.]/, "delimiter"],
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        [/"/, "string", "@string"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/\/\*/, "comment", "@comment"],
+        [/\/\/.*$/, "comment"]
+      ],
+      comment: [
+        [/[^\/*]+/, "comment"],
+        [/\*\//, "comment", "@pop"],
+        [/[\/*]/, "comment"]
+      ],
+      string: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, "string", "@pop"]
+      ]
+    }
+  };
+  return flow9_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/fsharp/fsharp.js

@@ -0,0 +1,227 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/fsharp/fsharp",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/fsharp/fsharp.ts
+  var fsharp_exports = {};
+  __export(fsharp_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "//",
+      blockComment: ["(*", "*)"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*//\\s*#region\\b|^\\s*\\(\\*\\s*#region(.*)\\*\\)"),
+        end: new RegExp("^\\s*//\\s*#endregion\\b|^\\s*\\(\\*\\s*#endregion\\s*\\*\\)")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".fs",
+    keywords: [
+      "abstract",
+      "and",
+      "atomic",
+      "as",
+      "assert",
+      "asr",
+      "base",
+      "begin",
+      "break",
+      "checked",
+      "component",
+      "const",
+      "constraint",
+      "constructor",
+      "continue",
+      "class",
+      "default",
+      "delegate",
+      "do",
+      "done",
+      "downcast",
+      "downto",
+      "elif",
+      "else",
+      "end",
+      "exception",
+      "eager",
+      "event",
+      "external",
+      "extern",
+      "false",
+      "finally",
+      "for",
+      "fun",
+      "function",
+      "fixed",
+      "functor",
+      "global",
+      "if",
+      "in",
+      "include",
+      "inherit",
+      "inline",
+      "interface",
+      "internal",
+      "land",
+      "lor",
+      "lsl",
+      "lsr",
+      "lxor",
+      "lazy",
+      "let",
+      "match",
+      "member",
+      "mod",
+      "module",
+      "mutable",
+      "namespace",
+      "method",
+      "mixin",
+      "new",
+      "not",
+      "null",
+      "of",
+      "open",
+      "or",
+      "object",
+      "override",
+      "private",
+      "parallel",
+      "process",
+      "protected",
+      "pure",
+      "public",
+      "rec",
+      "return",
+      "static",
+      "sealed",
+      "struct",
+      "sig",
+      "then",
+      "to",
+      "true",
+      "tailcall",
+      "trait",
+      "try",
+      "type",
+      "upcast",
+      "use",
+      "val",
+      "void",
+      "virtual",
+      "volatile",
+      "when",
+      "while",
+      "with",
+      "yield"
+    ],
+    symbols: /[=><!~?:&|+\-*\^%;\.,\/]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    integersuffix: /[uU]?[yslnLI]?/,
+    floatsuffix: /[fFmM]?/,
+    tokenizer: {
+      root: [
+        [
+          /[a-zA-Z_]\w*/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@default": "identifier"
+            }
+          }
+        ],
+        { include: "@whitespace" },
+        [/\[<.*>\]/, "annotation"],
+        [/^#(if|else|endif)/, "keyword"],
+        [/[{}()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [/@symbols/, "delimiter"],
+        [/\d*\d+[eE]([\-+]?\d+)?(@floatsuffix)/, "number.float"],
+        [/\d*\.\d+([eE][\-+]?\d+)?(@floatsuffix)/, "number.float"],
+        [/0x[0-9a-fA-F]+LF/, "number.float"],
+        [/0x[0-9a-fA-F]+(@integersuffix)/, "number.hex"],
+        [/0b[0-1]+(@integersuffix)/, "number.bin"],
+        [/\d+(@integersuffix)/, "number"],
+        [/[;,.]/, "delimiter"],
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        [/"""/, "string", '@string."""'],
+        [/"/, "string", '@string."'],
+        [/\@"/, { token: "string.quote", next: "@litstring" }],
+        [/'[^\\']'B?/, "string"],
+        [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+        [/'/, "string.invalid"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/\(\*(?!\))/, "comment", "@comment"],
+        [/\/\/.*$/, "comment"]
+      ],
+      comment: [
+        [/[^*(]+/, "comment"],
+        [/\*\)/, "comment", "@pop"],
+        [/\*/, "comment"],
+        [/\(\*\)/, "comment"],
+        [/\(/, "comment"]
+      ],
+      string: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [
+          /("""|"B?)/,
+          {
+            cases: {
+              "$#==$S2": { token: "string", next: "@pop" },
+              "@default": "string"
+            }
+          }
+        ]
+      ],
+      litstring: [
+        [/[^"]+/, "string"],
+        [/""/, "string.escape"],
+        [/"/, { token: "string.quote", next: "@pop" }]
+      ]
+    }
+  };
+  return fsharp_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/go/go.js

@@ -0,0 +1,225 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/go/go",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/go/go.ts
+  var go_exports = {};
+  __export(go_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "`", close: "`", notIn: ["string"] },
+      { open: '"', close: '"', notIn: ["string"] },
+      { open: "'", close: "'", notIn: ["string", "comment"] }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "`", close: "`" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".go",
+    keywords: [
+      "break",
+      "case",
+      "chan",
+      "const",
+      "continue",
+      "default",
+      "defer",
+      "else",
+      "fallthrough",
+      "for",
+      "func",
+      "go",
+      "goto",
+      "if",
+      "import",
+      "interface",
+      "map",
+      "package",
+      "range",
+      "return",
+      "select",
+      "struct",
+      "switch",
+      "type",
+      "var",
+      "bool",
+      "true",
+      "false",
+      "uint8",
+      "uint16",
+      "uint32",
+      "uint64",
+      "int8",
+      "int16",
+      "int32",
+      "int64",
+      "float32",
+      "float64",
+      "complex64",
+      "complex128",
+      "byte",
+      "rune",
+      "uint",
+      "int",
+      "uintptr",
+      "string",
+      "nil"
+    ],
+    operators: [
+      "+",
+      "-",
+      "*",
+      "/",
+      "%",
+      "&",
+      "|",
+      "^",
+      "<<",
+      ">>",
+      "&^",
+      "+=",
+      "-=",
+      "*=",
+      "/=",
+      "%=",
+      "&=",
+      "|=",
+      "^=",
+      "<<=",
+      ">>=",
+      "&^=",
+      "&&",
+      "||",
+      "<-",
+      "++",
+      "--",
+      "==",
+      "<",
+      ">",
+      "=",
+      "!",
+      "!=",
+      "<=",
+      ">=",
+      ":=",
+      "...",
+      "(",
+      ")",
+      "",
+      "]",
+      "{",
+      "}",
+      ",",
+      ";",
+      ".",
+      ":"
+    ],
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    tokenizer: {
+      root: [
+        [
+          /[a-zA-Z_]\w*/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@default": "identifier"
+            }
+          }
+        ],
+        { include: "@whitespace" },
+        [/\[\[.*\]\]/, "annotation"],
+        [/^\s*#\w+/, "keyword"],
+        [/[{}()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "delimiter",
+              "@default": ""
+            }
+          }
+        ],
+        [/\d*\d+[eE]([\-+]?\d+)?/, "number.float"],
+        [/\d*\.\d+([eE][\-+]?\d+)?/, "number.float"],
+        [/0[xX][0-9a-fA-F']*[0-9a-fA-F]/, "number.hex"],
+        [/0[0-7']*[0-7]/, "number.octal"],
+        [/0[bB][0-1']*[0-1]/, "number.binary"],
+        [/\d[\d']*/, "number"],
+        [/\d/, "number"],
+        [/[;,.]/, "delimiter"],
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        [/"/, "string", "@string"],
+        [/`/, "string", "@rawstring"],
+        [/'[^\\']'/, "string"],
+        [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+        [/'/, "string.invalid"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/\/\*\*(?!\/)/, "comment.doc", "@doccomment"],
+        [/\/\*/, "comment", "@comment"],
+        [/\/\/.*$/, "comment"]
+      ],
+      comment: [
+        [/[^\/*]+/, "comment"],
+        [/\*\//, "comment", "@pop"],
+        [/[\/*]/, "comment"]
+      ],
+      doccomment: [
+        [/[^\/*]+/, "comment.doc"],
+        [/\/\*/, "comment.doc.invalid"],
+        [/\*\//, "comment.doc", "@pop"],
+        [/[\/*]/, "comment.doc"]
+      ],
+      string: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, "string", "@pop"]
+      ],
+      rawstring: [
+        [/[^\`]/, "string"],
+        [/`/, "string", "@pop"]
+      ]
+    }
+  };
+  return go_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/graphql/graphql.js

@@ -0,0 +1,158 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/graphql/graphql",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/graphql/graphql.ts
+  var graphql_exports = {};
+  __export(graphql_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "#"
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"""', close: '"""', notIn: ["string", "comment"] },
+      { open: '"', close: '"', notIn: ["string", "comment"] }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"""', close: '"""' },
+      { open: '"', close: '"' }
+    ],
+    folding: {
+      offSide: true
+    }
+  };
+  var language = {
+    defaultToken: "invalid",
+    tokenPostfix: ".gql",
+    keywords: [
+      "null",
+      "true",
+      "false",
+      "query",
+      "mutation",
+      "subscription",
+      "extend",
+      "schema",
+      "directive",
+      "scalar",
+      "type",
+      "interface",
+      "union",
+      "enum",
+      "input",
+      "implements",
+      "fragment",
+      "on"
+    ],
+    typeKeywords: ["Int", "Float", "String", "Boolean", "ID"],
+    directiveLocations: [
+      "SCHEMA",
+      "SCALAR",
+      "OBJECT",
+      "FIELD_DEFINITION",
+      "ARGUMENT_DEFINITION",
+      "INTERFACE",
+      "UNION",
+      "ENUM",
+      "ENUM_VALUE",
+      "INPUT_OBJECT",
+      "INPUT_FIELD_DEFINITION",
+      "QUERY",
+      "MUTATION",
+      "SUBSCRIPTION",
+      "FIELD",
+      "FRAGMENT_DEFINITION",
+      "FRAGMENT_SPREAD",
+      "INLINE_FRAGMENT",
+      "VARIABLE_DEFINITION"
+    ],
+    operators: ["=", "!", "?", ":", "&", "|"],
+    symbols: /[=!?:&|]+/,
+    escapes: /\\(?:["\\\/bfnrt]|u[0-9A-Fa-f]{4})/,
+    tokenizer: {
+      root: [
+        [
+          /[a-z_][\w$]*/,
+          {
+            cases: {
+              "@keywords": "keyword",
+              "@default": "key.identifier"
+            }
+          }
+        ],
+        [
+          /[$][\w$]*/,
+          {
+            cases: {
+              "@keywords": "keyword",
+              "@default": "argument.identifier"
+            }
+          }
+        ],
+        [
+          /[A-Z][\w\$]*/,
+          {
+            cases: {
+              "@typeKeywords": "keyword",
+              "@default": "type.identifier"
+            }
+          }
+        ],
+        { include: "@whitespace" },
+        [/[{}()\[\]]/, "@brackets"],
+        [/@symbols/, { cases: { "@operators": "operator", "@default": "" } }],
+        [/@\s*[a-zA-Z_\$][\w\$]*/, { token: "annotation", log: "annotation token: $0" }],
+        [/\d*\.\d+([eE][\-+]?\d+)?/, "number.float"],
+        [/0[xX][0-9a-fA-F]+/, "number.hex"],
+        [/\d+/, "number"],
+        [/[;,.]/, "delimiter"],
+        [/"""/, { token: "string", next: "@mlstring", nextEmbedded: "markdown" }],
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        [/"/, { token: "string.quote", bracket: "@open", next: "@string" }]
+      ],
+      mlstring: [
+        [/[^"]+/, "string"],
+        ['"""', { token: "string", next: "@pop", nextEmbedded: "@pop" }]
+      ],
+      string: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, { token: "string.quote", bracket: "@close", next: "@pop" }]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/#.*$/, "comment"]
+      ]
+    }
+  };
+  return graphql_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/handlebars/handlebars.js

@@ -0,0 +1,434 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/handlebars/handlebars",[],()=>{
+var moduleExports = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __reExport = (target, module, desc) => {
+    if (module && typeof module === "object" || typeof module === "function") {
+      for (let key of __getOwnPropNames(module))
+        if (!__hasOwnProp.call(target, key) && key !== "default")
+          __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
+    }
+    return target;
+  };
+  var __toModule = (module) => {
+    return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", module && module.__esModule && "default" in module ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
+  };
+
+  // build/fillers/monaco-editor-core-amd.ts
+  var require_monaco_editor_core_amd = __commonJS({
+    "build/fillers/monaco-editor-core-amd.ts"(exports, module) {
+      module.exports = self.monaco;
+    }
+  });
+
+  // src/basic-languages/handlebars/handlebars.ts
+  var handlebars_exports = {};
+  __export(handlebars_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+
+  // src/fillers/monaco-editor-core.ts
+  var monaco_editor_core_exports = {};
+  __markAsModule(monaco_editor_core_exports);
+  __reExport(monaco_editor_core_exports, __toModule(require_monaco_editor_core_amd()));
+
+  // src/basic-languages/handlebars/handlebars.ts
+  var EMPTY_ELEMENTS = [
+    "area",
+    "base",
+    "br",
+    "col",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "keygen",
+    "link",
+    "menuitem",
+    "meta",
+    "param",
+    "source",
+    "track",
+    "wbr"
+  ];
+  var conf = {
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\$\^\&\*\(\)\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\s]+)/g,
+    comments: {
+      blockComment: ["{{!--", "--}}"]
+    },
+    brackets: [
+      ["<!--", "-->"],
+      ["<", ">"],
+      ["{{", "}}"],
+      ["{", "}"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "<", close: ">" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    onEnterRules: [
+      {
+        beforeText: new RegExp(`<(?!(?:${EMPTY_ELEMENTS.join("|")}))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$`, "i"),
+        afterText: /^<\/(\w[\w\d]*)\s*>$/i,
+        action: {
+          indentAction: monaco_editor_core_exports.languages.IndentAction.IndentOutdent
+        }
+      },
+      {
+        beforeText: new RegExp(`<(?!(?:${EMPTY_ELEMENTS.join("|")}))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$`, "i"),
+        action: { indentAction: monaco_editor_core_exports.languages.IndentAction.Indent }
+      }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: "",
+    tokenizer: {
+      root: [
+        [/\{\{!--/, "comment.block.start.handlebars", "@commentBlock"],
+        [/\{\{!/, "comment.start.handlebars", "@comment"],
+        [/\{\{/, { token: "@rematch", switchTo: "@handlebarsInSimpleState.root" }],
+        [/<!DOCTYPE/, "metatag.html", "@doctype"],
+        [/<!--/, "comment.html", "@commentHtml"],
+        [/(<)(\w+)(\/>)/, ["delimiter.html", "tag.html", "delimiter.html"]],
+        [/(<)(script)/, ["delimiter.html", { token: "tag.html", next: "@script" }]],
+        [/(<)(style)/, ["delimiter.html", { token: "tag.html", next: "@style" }]],
+        [/(<)([:\w]+)/, ["delimiter.html", { token: "tag.html", next: "@otherTag" }]],
+        [/(<\/)(\w+)/, ["delimiter.html", { token: "tag.html", next: "@otherTag" }]],
+        [/</, "delimiter.html"],
+        [/\{/, "delimiter.html"],
+        [/[^<{]+/]
+      ],
+      doctype: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInSimpleState.comment"
+          }
+        ],
+        [/[^>]+/, "metatag.content.html"],
+        [/>/, "metatag.html", "@pop"]
+      ],
+      comment: [
+        [/\}\}/, "comment.end.handlebars", "@pop"],
+        [/./, "comment.content.handlebars"]
+      ],
+      commentBlock: [
+        [/--\}\}/, "comment.block.end.handlebars", "@pop"],
+        [/./, "comment.content.handlebars"]
+      ],
+      commentHtml: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInSimpleState.comment"
+          }
+        ],
+        [/-->/, "comment.html", "@pop"],
+        [/[^-]+/, "comment.content.html"],
+        [/./, "comment.content.html"]
+      ],
+      otherTag: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInSimpleState.otherTag"
+          }
+        ],
+        [/\/?>/, "delimiter.html", "@pop"],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [/[ \t\r\n]+/]
+      ],
+      script: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInSimpleState.script"
+          }
+        ],
+        [/type/, "attribute.name", "@scriptAfterType"],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@scriptEmbedded.text/javascript",
+            nextEmbedded: "text/javascript"
+          }
+        ],
+        [/[ \t\r\n]+/],
+        [
+          /(<\/)(script\s*)(>)/,
+          ["delimiter.html", "tag.html", { token: "delimiter.html", next: "@pop" }]
+        ]
+      ],
+      scriptAfterType: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInSimpleState.scriptAfterType"
+          }
+        ],
+        [/=/, "delimiter", "@scriptAfterTypeEquals"],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@scriptEmbedded.text/javascript",
+            nextEmbedded: "text/javascript"
+          }
+        ],
+        [/[ \t\r\n]+/],
+        [/<\/script\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      scriptAfterTypeEquals: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInSimpleState.scriptAfterTypeEquals"
+          }
+        ],
+        [
+          /"([^"]*)"/,
+          {
+            token: "attribute.value",
+            switchTo: "@scriptWithCustomType.$1"
+          }
+        ],
+        [
+          /'([^']*)'/,
+          {
+            token: "attribute.value",
+            switchTo: "@scriptWithCustomType.$1"
+          }
+        ],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@scriptEmbedded.text/javascript",
+            nextEmbedded: "text/javascript"
+          }
+        ],
+        [/[ \t\r\n]+/],
+        [/<\/script\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      scriptWithCustomType: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInSimpleState.scriptWithCustomType.$S2"
+          }
+        ],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@scriptEmbedded.$S2",
+            nextEmbedded: "$S2"
+          }
+        ],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [/[ \t\r\n]+/],
+        [/<\/script\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      scriptEmbedded: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInEmbeddedState.scriptEmbedded.$S2",
+            nextEmbedded: "@pop"
+          }
+        ],
+        [/<\/script/, { token: "@rematch", next: "@pop", nextEmbedded: "@pop" }]
+      ],
+      style: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInSimpleState.style"
+          }
+        ],
+        [/type/, "attribute.name", "@styleAfterType"],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@styleEmbedded.text/css",
+            nextEmbedded: "text/css"
+          }
+        ],
+        [/[ \t\r\n]+/],
+        [
+          /(<\/)(style\s*)(>)/,
+          ["delimiter.html", "tag.html", { token: "delimiter.html", next: "@pop" }]
+        ]
+      ],
+      styleAfterType: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInSimpleState.styleAfterType"
+          }
+        ],
+        [/=/, "delimiter", "@styleAfterTypeEquals"],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@styleEmbedded.text/css",
+            nextEmbedded: "text/css"
+          }
+        ],
+        [/[ \t\r\n]+/],
+        [/<\/style\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      styleAfterTypeEquals: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInSimpleState.styleAfterTypeEquals"
+          }
+        ],
+        [
+          /"([^"]*)"/,
+          {
+            token: "attribute.value",
+            switchTo: "@styleWithCustomType.$1"
+          }
+        ],
+        [
+          /'([^']*)'/,
+          {
+            token: "attribute.value",
+            switchTo: "@styleWithCustomType.$1"
+          }
+        ],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@styleEmbedded.text/css",
+            nextEmbedded: "text/css"
+          }
+        ],
+        [/[ \t\r\n]+/],
+        [/<\/style\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      styleWithCustomType: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInSimpleState.styleWithCustomType.$S2"
+          }
+        ],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@styleEmbedded.$S2",
+            nextEmbedded: "$S2"
+          }
+        ],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [/[ \t\r\n]+/],
+        [/<\/style\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      styleEmbedded: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInEmbeddedState.styleEmbedded.$S2",
+            nextEmbedded: "@pop"
+          }
+        ],
+        [/<\/style/, { token: "@rematch", next: "@pop", nextEmbedded: "@pop" }]
+      ],
+      handlebarsInSimpleState: [
+        [/\{\{\{?/, "delimiter.handlebars"],
+        [/\}\}\}?/, { token: "delimiter.handlebars", switchTo: "@$S2.$S3" }],
+        { include: "handlebarsRoot" }
+      ],
+      handlebarsInEmbeddedState: [
+        [/\{\{\{?/, "delimiter.handlebars"],
+        [
+          /\}\}\}?/,
+          {
+            token: "delimiter.handlebars",
+            switchTo: "@$S2.$S3",
+            nextEmbedded: "$S3"
+          }
+        ],
+        { include: "handlebarsRoot" }
+      ],
+      handlebarsRoot: [
+        [/"[^"]*"/, "string.handlebars"],
+        [/[#/][^\s}]+/, "keyword.helper.handlebars"],
+        [/else\b/, "keyword.helper.handlebars"],
+        [/[\s]+/],
+        [/[^}]/, "variable.parameter.handlebars"]
+      ]
+    }
+  };
+  return handlebars_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/html/html.js

@@ -0,0 +1,310 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/html/html",[],()=>{
+var moduleExports = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __reExport = (target, module, desc) => {
+    if (module && typeof module === "object" || typeof module === "function") {
+      for (let key of __getOwnPropNames(module))
+        if (!__hasOwnProp.call(target, key) && key !== "default")
+          __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
+    }
+    return target;
+  };
+  var __toModule = (module) => {
+    return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", module && module.__esModule && "default" in module ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
+  };
+
+  // build/fillers/monaco-editor-core-amd.ts
+  var require_monaco_editor_core_amd = __commonJS({
+    "build/fillers/monaco-editor-core-amd.ts"(exports, module) {
+      module.exports = self.monaco;
+    }
+  });
+
+  // src/basic-languages/html/html.ts
+  var html_exports = {};
+  __export(html_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+
+  // src/fillers/monaco-editor-core.ts
+  var monaco_editor_core_exports = {};
+  __markAsModule(monaco_editor_core_exports);
+  __reExport(monaco_editor_core_exports, __toModule(require_monaco_editor_core_amd()));
+
+  // src/basic-languages/html/html.ts
+  var EMPTY_ELEMENTS = [
+    "area",
+    "base",
+    "br",
+    "col",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "keygen",
+    "link",
+    "menuitem",
+    "meta",
+    "param",
+    "source",
+    "track",
+    "wbr"
+  ];
+  var conf = {
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\$\^\&\*\(\)\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\s]+)/g,
+    comments: {
+      blockComment: ["<!--", "-->"]
+    },
+    brackets: [
+      ["<!--", "-->"],
+      ["<", ">"],
+      ["{", "}"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "<", close: ">" }
+    ],
+    onEnterRules: [
+      {
+        beforeText: new RegExp(`<(?!(?:${EMPTY_ELEMENTS.join("|")}))([_:\\w][_:\\w-.\\d]*)([^/>]*(?!/)>)[^<]*$`, "i"),
+        afterText: /^<\/([_:\w][_:\w-.\d]*)\s*>$/i,
+        action: {
+          indentAction: monaco_editor_core_exports.languages.IndentAction.IndentOutdent
+        }
+      },
+      {
+        beforeText: new RegExp(`<(?!(?:${EMPTY_ELEMENTS.join("|")}))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$`, "i"),
+        action: { indentAction: monaco_editor_core_exports.languages.IndentAction.Indent }
+      }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*<!--\\s*#region\\b.*-->"),
+        end: new RegExp("^\\s*<!--\\s*#endregion\\b.*-->")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".html",
+    ignoreCase: true,
+    tokenizer: {
+      root: [
+        [/<!DOCTYPE/, "metatag", "@doctype"],
+        [/<!--/, "comment", "@comment"],
+        [/(<)((?:[\w\-]+:)?[\w\-]+)(\s*)(\/>)/, ["delimiter", "tag", "", "delimiter"]],
+        [/(<)(script)/, ["delimiter", { token: "tag", next: "@script" }]],
+        [/(<)(style)/, ["delimiter", { token: "tag", next: "@style" }]],
+        [/(<)((?:[\w\-]+:)?[\w\-]+)/, ["delimiter", { token: "tag", next: "@otherTag" }]],
+        [/(<\/)((?:[\w\-]+:)?[\w\-]+)/, ["delimiter", { token: "tag", next: "@otherTag" }]],
+        [/</, "delimiter"],
+        [/[^<]+/]
+      ],
+      doctype: [
+        [/[^>]+/, "metatag.content"],
+        [/>/, "metatag", "@pop"]
+      ],
+      comment: [
+        [/-->/, "comment", "@pop"],
+        [/[^-]+/, "comment.content"],
+        [/./, "comment.content"]
+      ],
+      otherTag: [
+        [/\/?>/, "delimiter", "@pop"],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [/[ \t\r\n]+/]
+      ],
+      script: [
+        [/type/, "attribute.name", "@scriptAfterType"],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [
+          />/,
+          {
+            token: "delimiter",
+            next: "@scriptEmbedded",
+            nextEmbedded: "text/javascript"
+          }
+        ],
+        [/[ \t\r\n]+/],
+        [/(<\/)(script\s*)(>)/, ["delimiter", "tag", { token: "delimiter", next: "@pop" }]]
+      ],
+      scriptAfterType: [
+        [/=/, "delimiter", "@scriptAfterTypeEquals"],
+        [
+          />/,
+          {
+            token: "delimiter",
+            next: "@scriptEmbedded",
+            nextEmbedded: "text/javascript"
+          }
+        ],
+        [/[ \t\r\n]+/],
+        [/<\/script\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      scriptAfterTypeEquals: [
+        [
+          /"([^"]*)"/,
+          {
+            token: "attribute.value",
+            switchTo: "@scriptWithCustomType.$1"
+          }
+        ],
+        [
+          /'([^']*)'/,
+          {
+            token: "attribute.value",
+            switchTo: "@scriptWithCustomType.$1"
+          }
+        ],
+        [
+          />/,
+          {
+            token: "delimiter",
+            next: "@scriptEmbedded",
+            nextEmbedded: "text/javascript"
+          }
+        ],
+        [/[ \t\r\n]+/],
+        [/<\/script\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      scriptWithCustomType: [
+        [
+          />/,
+          {
+            token: "delimiter",
+            next: "@scriptEmbedded.$S2",
+            nextEmbedded: "$S2"
+          }
+        ],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [/[ \t\r\n]+/],
+        [/<\/script\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      scriptEmbedded: [
+        [/<\/script/, { token: "@rematch", next: "@pop", nextEmbedded: "@pop" }],
+        [/[^<]+/, ""]
+      ],
+      style: [
+        [/type/, "attribute.name", "@styleAfterType"],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [
+          />/,
+          {
+            token: "delimiter",
+            next: "@styleEmbedded",
+            nextEmbedded: "text/css"
+          }
+        ],
+        [/[ \t\r\n]+/],
+        [/(<\/)(style\s*)(>)/, ["delimiter", "tag", { token: "delimiter", next: "@pop" }]]
+      ],
+      styleAfterType: [
+        [/=/, "delimiter", "@styleAfterTypeEquals"],
+        [
+          />/,
+          {
+            token: "delimiter",
+            next: "@styleEmbedded",
+            nextEmbedded: "text/css"
+          }
+        ],
+        [/[ \t\r\n]+/],
+        [/<\/style\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      styleAfterTypeEquals: [
+        [
+          /"([^"]*)"/,
+          {
+            token: "attribute.value",
+            switchTo: "@styleWithCustomType.$1"
+          }
+        ],
+        [
+          /'([^']*)'/,
+          {
+            token: "attribute.value",
+            switchTo: "@styleWithCustomType.$1"
+          }
+        ],
+        [
+          />/,
+          {
+            token: "delimiter",
+            next: "@styleEmbedded",
+            nextEmbedded: "text/css"
+          }
+        ],
+        [/[ \t\r\n]+/],
+        [/<\/style\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      styleWithCustomType: [
+        [
+          />/,
+          {
+            token: "delimiter",
+            next: "@styleEmbedded.$S2",
+            nextEmbedded: "$S2"
+          }
+        ],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [/[ \t\r\n]+/],
+        [/<\/style\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      styleEmbedded: [
+        [/<\/style/, { token: "@rematch", next: "@pop", nextEmbedded: "@pop" }],
+        [/[^<]+/, ""]
+      ]
+    }
+  };
+  return html_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/ini/ini.js

@@ -0,0 +1,85 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/ini/ini",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/ini/ini.ts
+  var ini_exports = {};
+  __export(ini_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "#"
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".ini",
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    tokenizer: {
+      root: [
+        [/^\[[^\]]*\]/, "metatag"],
+        [/(^\w+)(\s*)(\=)/, ["key", "", "delimiter"]],
+        { include: "@whitespace" },
+        [/\d+/, "number"],
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        [/'([^'\\]|\\.)*$/, "string.invalid"],
+        [/"/, "string", '@string."'],
+        [/'/, "string", "@string.'"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/^\s*[#;].*$/, "comment"]
+      ],
+      string: [
+        [/[^\\"']+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [
+          /["']/,
+          {
+            cases: {
+              "$#==$S2": { token: "string", next: "@pop" },
+              "@default": "string"
+            }
+          }
+        ]
+      ]
+    }
+  };
+  return ini_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/java/java.js

@@ -0,0 +1,238 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/java/java",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/java/java.ts
+  var java_exports = {};
+  __export(java_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: "<", close: ">" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*//\\s*(?:(?:#?region\\b)|(?:<editor-fold\\b))"),
+        end: new RegExp("^\\s*//\\s*(?:(?:#?endregion\\b)|(?:</editor-fold>))")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".java",
+    keywords: [
+      "abstract",
+      "continue",
+      "for",
+      "new",
+      "switch",
+      "assert",
+      "default",
+      "goto",
+      "package",
+      "synchronized",
+      "boolean",
+      "do",
+      "if",
+      "private",
+      "this",
+      "break",
+      "double",
+      "implements",
+      "protected",
+      "throw",
+      "byte",
+      "else",
+      "import",
+      "public",
+      "throws",
+      "case",
+      "enum",
+      "instanceof",
+      "return",
+      "transient",
+      "catch",
+      "extends",
+      "int",
+      "short",
+      "try",
+      "char",
+      "final",
+      "interface",
+      "static",
+      "void",
+      "class",
+      "finally",
+      "long",
+      "strictfp",
+      "volatile",
+      "const",
+      "float",
+      "native",
+      "super",
+      "while",
+      "true",
+      "false",
+      "yield",
+      "record",
+      "sealed",
+      "non-sealed",
+      "permits"
+    ],
+    operators: [
+      "=",
+      ">",
+      "<",
+      "!",
+      "~",
+      "?",
+      ":",
+      "==",
+      "<=",
+      ">=",
+      "!=",
+      "&&",
+      "||",
+      "++",
+      "--",
+      "+",
+      "-",
+      "*",
+      "/",
+      "&",
+      "|",
+      "^",
+      "%",
+      "<<",
+      ">>",
+      ">>>",
+      "+=",
+      "-=",
+      "*=",
+      "/=",
+      "&=",
+      "|=",
+      "^=",
+      "%=",
+      "<<=",
+      ">>=",
+      ">>>="
+    ],
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    digits: /\d+(_+\d+)*/,
+    octaldigits: /[0-7]+(_+[0-7]+)*/,
+    binarydigits: /[0-1]+(_+[0-1]+)*/,
+    hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+    tokenizer: {
+      root: [
+        ["non-sealed", "keyword.non-sealed"],
+        [
+          /[a-zA-Z_$][\w$]*/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@default": "identifier"
+            }
+          }
+        ],
+        { include: "@whitespace" },
+        [/[{}()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "delimiter",
+              "@default": ""
+            }
+          }
+        ],
+        [/@\s*[a-zA-Z_\$][\w\$]*/, "annotation"],
+        [/(@digits)[eE]([\-+]?(@digits))?[fFdD]?/, "number.float"],
+        [/(@digits)\.(@digits)([eE][\-+]?(@digits))?[fFdD]?/, "number.float"],
+        [/0[xX](@hexdigits)[Ll]?/, "number.hex"],
+        [/0(@octaldigits)[Ll]?/, "number.octal"],
+        [/0[bB](@binarydigits)[Ll]?/, "number.binary"],
+        [/(@digits)[fFdD]/, "number.float"],
+        [/(@digits)[lL]?/, "number"],
+        [/[;,.]/, "delimiter"],
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        [/"""/, "string", "@multistring"],
+        [/"/, "string", "@string"],
+        [/'[^\\']'/, "string"],
+        [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+        [/'/, "string.invalid"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/\/\*\*(?!\/)/, "comment.doc", "@javadoc"],
+        [/\/\*/, "comment", "@comment"],
+        [/\/\/.*$/, "comment"]
+      ],
+      comment: [
+        [/[^\/*]+/, "comment"],
+        [/\*\//, "comment", "@pop"],
+        [/[\/*]/, "comment"]
+      ],
+      javadoc: [
+        [/[^\/*]+/, "comment.doc"],
+        [/\/\*/, "comment.doc.invalid"],
+        [/\*\//, "comment.doc", "@pop"],
+        [/[\/*]/, "comment.doc"]
+      ],
+      string: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, "string", "@pop"]
+      ],
+      multistring: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"""/, "string", "@pop"],
+        [/./, "string"]
+      ]
+    }
+  };
+  return java_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/javascript/javascript.js

@@ -0,0 +1,434 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/javascript/javascript",[],()=>{
+var moduleExports = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __reExport = (target, module, desc) => {
+    if (module && typeof module === "object" || typeof module === "function") {
+      for (let key of __getOwnPropNames(module))
+        if (!__hasOwnProp.call(target, key) && key !== "default")
+          __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
+    }
+    return target;
+  };
+  var __toModule = (module) => {
+    return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", module && module.__esModule && "default" in module ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
+  };
+
+  // build/fillers/monaco-editor-core-amd.ts
+  var require_monaco_editor_core_amd = __commonJS({
+    "build/fillers/monaco-editor-core-amd.ts"(exports, module) {
+      module.exports = self.monaco;
+    }
+  });
+
+  // src/basic-languages/javascript/javascript.ts
+  var javascript_exports = {};
+  __export(javascript_exports, {
+    conf: () => conf2,
+    language: () => language2
+  });
+
+  // src/fillers/monaco-editor-core.ts
+  var monaco_editor_core_exports = {};
+  __markAsModule(monaco_editor_core_exports);
+  __reExport(monaco_editor_core_exports, __toModule(require_monaco_editor_core_amd()));
+
+  // src/basic-languages/typescript/typescript.ts
+  var conf = {
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    onEnterRules: [
+      {
+        beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
+        afterText: /^\s*\*\/$/,
+        action: {
+          indentAction: monaco_editor_core_exports.languages.IndentAction.IndentOutdent,
+          appendText: " * "
+        }
+      },
+      {
+        beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
+        action: {
+          indentAction: monaco_editor_core_exports.languages.IndentAction.None,
+          appendText: " * "
+        }
+      },
+      {
+        beforeText: /^(\t|(\ \ ))*\ \*(\ ([^\*]|\*(?!\/))*)?$/,
+        action: {
+          indentAction: monaco_editor_core_exports.languages.IndentAction.None,
+          appendText: "* "
+        }
+      },
+      {
+        beforeText: /^(\t|(\ \ ))*\ \*\/\s*$/,
+        action: {
+          indentAction: monaco_editor_core_exports.languages.IndentAction.None,
+          removeText: 1
+        }
+      }
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"', notIn: ["string"] },
+      { open: "'", close: "'", notIn: ["string", "comment"] },
+      { open: "`", close: "`", notIn: ["string", "comment"] },
+      { open: "/**", close: " */", notIn: ["string"] }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*//\\s*#?region\\b"),
+        end: new RegExp("^\\s*//\\s*#?endregion\\b")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "invalid",
+    tokenPostfix: ".ts",
+    keywords: [
+      "abstract",
+      "any",
+      "as",
+      "asserts",
+      "bigint",
+      "boolean",
+      "break",
+      "case",
+      "catch",
+      "class",
+      "continue",
+      "const",
+      "constructor",
+      "debugger",
+      "declare",
+      "default",
+      "delete",
+      "do",
+      "else",
+      "enum",
+      "export",
+      "extends",
+      "false",
+      "finally",
+      "for",
+      "from",
+      "function",
+      "get",
+      "if",
+      "implements",
+      "import",
+      "in",
+      "infer",
+      "instanceof",
+      "interface",
+      "is",
+      "keyof",
+      "let",
+      "module",
+      "namespace",
+      "never",
+      "new",
+      "null",
+      "number",
+      "object",
+      "package",
+      "private",
+      "protected",
+      "public",
+      "override",
+      "readonly",
+      "require",
+      "global",
+      "return",
+      "set",
+      "static",
+      "string",
+      "super",
+      "switch",
+      "symbol",
+      "this",
+      "throw",
+      "true",
+      "try",
+      "type",
+      "typeof",
+      "undefined",
+      "unique",
+      "unknown",
+      "var",
+      "void",
+      "while",
+      "with",
+      "yield",
+      "async",
+      "await",
+      "of"
+    ],
+    operators: [
+      "<=",
+      ">=",
+      "==",
+      "!=",
+      "===",
+      "!==",
+      "=>",
+      "+",
+      "-",
+      "**",
+      "*",
+      "/",
+      "%",
+      "++",
+      "--",
+      "<<",
+      "</",
+      ">>",
+      ">>>",
+      "&",
+      "|",
+      "^",
+      "!",
+      "~",
+      "&&",
+      "||",
+      "??",
+      "?",
+      ":",
+      "=",
+      "+=",
+      "-=",
+      "*=",
+      "**=",
+      "/=",
+      "%=",
+      "<<=",
+      ">>=",
+      ">>>=",
+      "&=",
+      "|=",
+      "^=",
+      "@"
+    ],
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    digits: /\d+(_+\d+)*/,
+    octaldigits: /[0-7]+(_+[0-7]+)*/,
+    binarydigits: /[0-1]+(_+[0-1]+)*/,
+    hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+    regexpctl: /[(){}\[\]\$\^|\-*+?\.]/,
+    regexpesc: /\\(?:[bBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})/,
+    tokenizer: {
+      root: [[/[{}]/, "delimiter.bracket"], { include: "common" }],
+      common: [
+        [
+          /[a-z_$][\w$]*/,
+          {
+            cases: {
+              "@keywords": "keyword",
+              "@default": "identifier"
+            }
+          }
+        ],
+        [/[A-Z][\w\$]*/, "type.identifier"],
+        { include: "@whitespace" },
+        [
+          /\/(?=([^\\\/]|\\.)+\/([dgimsuy]*)(\s*)(\.|;|,|\)|\]|\}|$))/,
+          { token: "regexp", bracket: "@open", next: "@regexp" }
+        ],
+        [/[()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [/!(?=([^=]|$))/, "delimiter"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "delimiter",
+              "@default": ""
+            }
+          }
+        ],
+        [/(@digits)[eE]([\-+]?(@digits))?/, "number.float"],
+        [/(@digits)\.(@digits)([eE][\-+]?(@digits))?/, "number.float"],
+        [/0[xX](@hexdigits)n?/, "number.hex"],
+        [/0[oO]?(@octaldigits)n?/, "number.octal"],
+        [/0[bB](@binarydigits)n?/, "number.binary"],
+        [/(@digits)n?/, "number"],
+        [/[;,.]/, "delimiter"],
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        [/'([^'\\]|\\.)*$/, "string.invalid"],
+        [/"/, "string", "@string_double"],
+        [/'/, "string", "@string_single"],
+        [/`/, "string", "@string_backtick"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/\/\*\*(?!\/)/, "comment.doc", "@jsdoc"],
+        [/\/\*/, "comment", "@comment"],
+        [/\/\/.*$/, "comment"]
+      ],
+      comment: [
+        [/[^\/*]+/, "comment"],
+        [/\*\//, "comment", "@pop"],
+        [/[\/*]/, "comment"]
+      ],
+      jsdoc: [
+        [/[^\/*]+/, "comment.doc"],
+        [/\*\//, "comment.doc", "@pop"],
+        [/[\/*]/, "comment.doc"]
+      ],
+      regexp: [
+        [
+          /(\{)(\d+(?:,\d*)?)(\})/,
+          ["regexp.escape.control", "regexp.escape.control", "regexp.escape.control"]
+        ],
+        [
+          /(\[)(\^?)(?=(?:[^\]\\\/]|\\.)+)/,
+          ["regexp.escape.control", { token: "regexp.escape.control", next: "@regexrange" }]
+        ],
+        [/(\()(\?:|\?=|\?!)/, ["regexp.escape.control", "regexp.escape.control"]],
+        [/[()]/, "regexp.escape.control"],
+        [/@regexpctl/, "regexp.escape.control"],
+        [/[^\\\/]/, "regexp"],
+        [/@regexpesc/, "regexp.escape"],
+        [/\\\./, "regexp.invalid"],
+        [/(\/)([dgimsuy]*)/, [{ token: "regexp", bracket: "@close", next: "@pop" }, "keyword.other"]]
+      ],
+      regexrange: [
+        [/-/, "regexp.escape.control"],
+        [/\^/, "regexp.invalid"],
+        [/@regexpesc/, "regexp.escape"],
+        [/[^\]]/, "regexp"],
+        [
+          /\]/,
+          {
+            token: "regexp.escape.control",
+            next: "@pop",
+            bracket: "@close"
+          }
+        ]
+      ],
+      string_double: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, "string", "@pop"]
+      ],
+      string_single: [
+        [/[^\\']+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/'/, "string", "@pop"]
+      ],
+      string_backtick: [
+        [/\$\{/, { token: "delimiter.bracket", next: "@bracketCounting" }],
+        [/[^\\`$]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/`/, "string", "@pop"]
+      ],
+      bracketCounting: [
+        [/\{/, "delimiter.bracket", "@bracketCounting"],
+        [/\}/, "delimiter.bracket", "@pop"],
+        { include: "common" }
+      ]
+    }
+  };
+
+  // src/basic-languages/javascript/javascript.ts
+  var conf2 = conf;
+  var language2 = {
+    defaultToken: "invalid",
+    tokenPostfix: ".js",
+    keywords: [
+      "break",
+      "case",
+      "catch",
+      "class",
+      "continue",
+      "const",
+      "constructor",
+      "debugger",
+      "default",
+      "delete",
+      "do",
+      "else",
+      "export",
+      "extends",
+      "false",
+      "finally",
+      "for",
+      "from",
+      "function",
+      "get",
+      "if",
+      "import",
+      "in",
+      "instanceof",
+      "let",
+      "new",
+      "null",
+      "return",
+      "set",
+      "super",
+      "switch",
+      "symbol",
+      "this",
+      "throw",
+      "true",
+      "try",
+      "typeof",
+      "undefined",
+      "var",
+      "void",
+      "while",
+      "with",
+      "yield",
+      "async",
+      "await",
+      "of"
+    ],
+    typeKeywords: [],
+    operators: language.operators,
+    symbols: language.symbols,
+    escapes: language.escapes,
+    digits: language.digits,
+    octaldigits: language.octaldigits,
+    binarydigits: language.binarydigits,
+    hexdigits: language.hexdigits,
+    regexpctl: language.regexpctl,
+    regexpesc: language.regexpesc,
+    tokenizer: language.tokenizer
+  };
+  return javascript_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/julia/julia.js

@@ -0,0 +1,513 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/julia/julia",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/julia/julia.ts
+  var julia_exports = {};
+  __export(julia_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ]
+  };
+  var language = {
+    tokenPostfix: ".julia",
+    keywords: [
+      "begin",
+      "while",
+      "if",
+      "for",
+      "try",
+      "return",
+      "break",
+      "continue",
+      "function",
+      "macro",
+      "quote",
+      "let",
+      "local",
+      "global",
+      "const",
+      "do",
+      "struct",
+      "module",
+      "baremodule",
+      "using",
+      "import",
+      "export",
+      "end",
+      "else",
+      "elseif",
+      "catch",
+      "finally",
+      "mutable",
+      "primitive",
+      "abstract",
+      "type",
+      "in",
+      "isa",
+      "where",
+      "new"
+    ],
+    types: [
+      "LinRange",
+      "LineNumberNode",
+      "LinearIndices",
+      "LoadError",
+      "MIME",
+      "Matrix",
+      "Method",
+      "MethodError",
+      "Missing",
+      "MissingException",
+      "Module",
+      "NTuple",
+      "NamedTuple",
+      "Nothing",
+      "Number",
+      "OrdinalRange",
+      "OutOfMemoryError",
+      "OverflowError",
+      "Pair",
+      "PartialQuickSort",
+      "PermutedDimsArray",
+      "Pipe",
+      "Ptr",
+      "QuoteNode",
+      "Rational",
+      "RawFD",
+      "ReadOnlyMemoryError",
+      "Real",
+      "ReentrantLock",
+      "Ref",
+      "Regex",
+      "RegexMatch",
+      "RoundingMode",
+      "SegmentationFault",
+      "Set",
+      "Signed",
+      "Some",
+      "StackOverflowError",
+      "StepRange",
+      "StepRangeLen",
+      "StridedArray",
+      "StridedMatrix",
+      "StridedVecOrMat",
+      "StridedVector",
+      "String",
+      "StringIndexError",
+      "SubArray",
+      "SubString",
+      "SubstitutionString",
+      "Symbol",
+      "SystemError",
+      "Task",
+      "Text",
+      "TextDisplay",
+      "Timer",
+      "Tuple",
+      "Type",
+      "TypeError",
+      "TypeVar",
+      "UInt",
+      "UInt128",
+      "UInt16",
+      "UInt32",
+      "UInt64",
+      "UInt8",
+      "UndefInitializer",
+      "AbstractArray",
+      "UndefKeywordError",
+      "AbstractChannel",
+      "UndefRefError",
+      "AbstractChar",
+      "UndefVarError",
+      "AbstractDict",
+      "Union",
+      "AbstractDisplay",
+      "UnionAll",
+      "AbstractFloat",
+      "UnitRange",
+      "AbstractIrrational",
+      "Unsigned",
+      "AbstractMatrix",
+      "AbstractRange",
+      "Val",
+      "AbstractSet",
+      "Vararg",
+      "AbstractString",
+      "VecElement",
+      "AbstractUnitRange",
+      "VecOrMat",
+      "AbstractVecOrMat",
+      "Vector",
+      "AbstractVector",
+      "VersionNumber",
+      "Any",
+      "WeakKeyDict",
+      "ArgumentError",
+      "WeakRef",
+      "Array",
+      "AssertionError",
+      "BigFloat",
+      "BigInt",
+      "BitArray",
+      "BitMatrix",
+      "BitSet",
+      "BitVector",
+      "Bool",
+      "BoundsError",
+      "CapturedException",
+      "CartesianIndex",
+      "CartesianIndices",
+      "Cchar",
+      "Cdouble",
+      "Cfloat",
+      "Channel",
+      "Char",
+      "Cint",
+      "Cintmax_t",
+      "Clong",
+      "Clonglong",
+      "Cmd",
+      "Colon",
+      "Complex",
+      "ComplexF16",
+      "ComplexF32",
+      "ComplexF64",
+      "CompositeException",
+      "Condition",
+      "Cptrdiff_t",
+      "Cshort",
+      "Csize_t",
+      "Cssize_t",
+      "Cstring",
+      "Cuchar",
+      "Cuint",
+      "Cuintmax_t",
+      "Culong",
+      "Culonglong",
+      "Cushort",
+      "Cvoid",
+      "Cwchar_t",
+      "Cwstring",
+      "DataType",
+      "DenseArray",
+      "DenseMatrix",
+      "DenseVecOrMat",
+      "DenseVector",
+      "Dict",
+      "DimensionMismatch",
+      "Dims",
+      "DivideError",
+      "DomainError",
+      "EOFError",
+      "Enum",
+      "ErrorException",
+      "Exception",
+      "ExponentialBackOff",
+      "Expr",
+      "Float16",
+      "Float32",
+      "Float64",
+      "Function",
+      "GlobalRef",
+      "HTML",
+      "IO",
+      "IOBuffer",
+      "IOContext",
+      "IOStream",
+      "IdDict",
+      "IndexCartesian",
+      "IndexLinear",
+      "IndexStyle",
+      "InexactError",
+      "InitError",
+      "Int",
+      "Int128",
+      "Int16",
+      "Int32",
+      "Int64",
+      "Int8",
+      "Integer",
+      "InterruptException",
+      "InvalidStateException",
+      "Irrational",
+      "KeyError"
+    ],
+    keywordops: ["<:", ">:", ":", "=>", "...", ".", "->", "?"],
+    allops: /[^\w\d\s()\[\]{}"'#]+/,
+    constants: [
+      "true",
+      "false",
+      "nothing",
+      "missing",
+      "undef",
+      "Inf",
+      "pi",
+      "NaN",
+      "\u03C0",
+      "\u212F",
+      "ans",
+      "PROGRAM_FILE",
+      "ARGS",
+      "C_NULL",
+      "VERSION",
+      "DEPOT_PATH",
+      "LOAD_PATH"
+    ],
+    operators: [
+      "!",
+      "!=",
+      "!==",
+      "%",
+      "&",
+      "*",
+      "+",
+      "-",
+      "/",
+      "//",
+      "<",
+      "<<",
+      "<=",
+      "==",
+      "===",
+      "=>",
+      ">",
+      ">=",
+      ">>",
+      ">>>",
+      "\\",
+      "^",
+      "|",
+      "|>",
+      "~",
+      "\xF7",
+      "\u2208",
+      "\u2209",
+      "\u220B",
+      "\u220C",
+      "\u2218",
+      "\u221A",
+      "\u221B",
+      "\u2229",
+      "\u222A",
+      "\u2248",
+      "\u2249",
+      "\u2260",
+      "\u2261",
+      "\u2262",
+      "\u2264",
+      "\u2265",
+      "\u2286",
+      "\u2287",
+      "\u2288",
+      "\u2289",
+      "\u228A",
+      "\u228B",
+      "\u22BB"
+    ],
+    brackets: [
+      { open: "(", close: ")", token: "delimiter.parenthesis" },
+      { open: "{", close: "}", token: "delimiter.curly" },
+      { open: "[", close: "]", token: "delimiter.square" }
+    ],
+    ident: /π|ℯ|\b(?!\d)\w+\b/,
+    escape: /(?:[abefnrstv\\"'\n\r]|[0-7]{1,3}|x[0-9A-Fa-f]{1,2}|u[0-9A-Fa-f]{4})/,
+    escapes: /\\(?:C\-(@escape|.)|c(@escape|.)|@escape)/,
+    tokenizer: {
+      root: [
+        [/(::)\s*|\b(isa)\s+/, "keyword", "@typeanno"],
+        [/\b(isa)(\s*\(@ident\s*,\s*)/, ["keyword", { token: "", next: "@typeanno" }]],
+        [/\b(type|struct)[ \t]+/, "keyword", "@typeanno"],
+        [/^\s*:@ident[!?]?/, "metatag"],
+        [/(return)(\s*:@ident[!?]?)/, ["keyword", "metatag"]],
+        [/(\(|\[|\{|@allops)(\s*:@ident[!?]?)/, ["", "metatag"]],
+        [/:\(/, "metatag", "@quote"],
+        [/r"""/, "regexp.delim", "@tregexp"],
+        [/r"/, "regexp.delim", "@sregexp"],
+        [/raw"""/, "string.delim", "@rtstring"],
+        [/[bv]?"""/, "string.delim", "@dtstring"],
+        [/raw"/, "string.delim", "@rsstring"],
+        [/[bv]?"/, "string.delim", "@dsstring"],
+        [
+          /(@ident)\{/,
+          {
+            cases: {
+              "$1@types": { token: "type", next: "@gen" },
+              "@default": { token: "type", next: "@gen" }
+            }
+          }
+        ],
+        [
+          /@ident[!?'']?(?=\.?\()/,
+          {
+            cases: {
+              "@types": "type",
+              "@keywords": "keyword",
+              "@constants": "variable",
+              "@default": "keyword.flow"
+            }
+          }
+        ],
+        [
+          /@ident[!?']?/,
+          {
+            cases: {
+              "@types": "type",
+              "@keywords": "keyword",
+              "@constants": "variable",
+              "@default": "identifier"
+            }
+          }
+        ],
+        [/\$\w+/, "key"],
+        [/\$\(/, "key", "@paste"],
+        [/@@@ident/, "annotation"],
+        { include: "@whitespace" },
+        [/'(?:@escapes|.)'/, "string.character"],
+        [/[()\[\]{}]/, "@brackets"],
+        [
+          /@allops/,
+          {
+            cases: {
+              "@keywordops": "keyword",
+              "@operators": "operator"
+            }
+          }
+        ],
+        [/[;,]/, "delimiter"],
+        [/0[xX][0-9a-fA-F](_?[0-9a-fA-F])*/, "number.hex"],
+        [/0[_oO][0-7](_?[0-7])*/, "number.octal"],
+        [/0[bB][01](_?[01])*/, "number.binary"],
+        [/[+\-]?\d+(\.\d+)?(im?|[eE][+\-]?\d+(\.\d+)?)?/, "number"]
+      ],
+      typeanno: [
+        [/[a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*\{/, "type", "@gen"],
+        [/([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)(\s*<:\s*)/, ["type", "keyword"]],
+        [/[a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*/, "type", "@pop"],
+        ["", "", "@pop"]
+      ],
+      gen: [
+        [/[a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*\{/, "type", "@push"],
+        [/[a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*/, "type"],
+        [/<:/, "keyword"],
+        [/(\})(\s*<:\s*)/, ["type", { token: "keyword", next: "@pop" }]],
+        [/\}/, "type", "@pop"],
+        { include: "@root" }
+      ],
+      quote: [
+        [/\$\(/, "key", "@paste"],
+        [/\(/, "@brackets", "@paren"],
+        [/\)/, "metatag", "@pop"],
+        { include: "@root" }
+      ],
+      paste: [
+        [/:\(/, "metatag", "@quote"],
+        [/\(/, "@brackets", "@paren"],
+        [/\)/, "key", "@pop"],
+        { include: "@root" }
+      ],
+      paren: [
+        [/\$\(/, "key", "@paste"],
+        [/:\(/, "metatag", "@quote"],
+        [/\(/, "@brackets", "@push"],
+        [/\)/, "@brackets", "@pop"],
+        { include: "@root" }
+      ],
+      sregexp: [
+        [/^.*/, "invalid"],
+        [/[^\\"()\[\]{}]/, "regexp"],
+        [/[()\[\]{}]/, "@brackets"],
+        [/\\./, "operator.scss"],
+        [/"[imsx]*/, "regexp.delim", "@pop"]
+      ],
+      tregexp: [
+        [/[^\\"()\[\]{}]/, "regexp"],
+        [/[()\[\]{}]/, "@brackets"],
+        [/\\./, "operator.scss"],
+        [/"(?!"")/, "string"],
+        [/"""[imsx]*/, "regexp.delim", "@pop"]
+      ],
+      rsstring: [
+        [/^.*/, "invalid"],
+        [/[^\\"]/, "string"],
+        [/\\./, "string.escape"],
+        [/"/, "string.delim", "@pop"]
+      ],
+      rtstring: [
+        [/[^\\"]/, "string"],
+        [/\\./, "string.escape"],
+        [/"(?!"")/, "string"],
+        [/"""/, "string.delim", "@pop"]
+      ],
+      dsstring: [
+        [/^.*/, "invalid"],
+        [/[^\\"\$]/, "string"],
+        [/\$/, "", "@interpolated"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, "string.delim", "@pop"]
+      ],
+      dtstring: [
+        [/[^\\"\$]/, "string"],
+        [/\$/, "", "@interpolated"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"(?!"")/, "string"],
+        [/"""/, "string.delim", "@pop"]
+      ],
+      interpolated: [
+        [/\(/, { token: "", switchTo: "@interpolated_compound" }],
+        [/[a-zA-Z_]\w*/, "identifier"],
+        ["", "", "@pop"]
+      ],
+      interpolated_compound: [[/\)/, "", "@pop"], { include: "@root" }],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/#=/, "comment", "@multi_comment"],
+        [/#.*$/, "comment"]
+      ],
+      multi_comment: [
+        [/#=/, "comment", "@push"],
+        [/=#/, "comment", "@pop"],
+        [/=(?!#)|#(?!=)/, "comment"],
+        [/[^#=]+/, "comment"]
+      ]
+    }
+  };
+  return julia_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/kotlin/kotlin.js

@@ -0,0 +1,262 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/kotlin/kotlin",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/kotlin/kotlin.ts
+  var kotlin_exports = {};
+  __export(kotlin_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: "<", close: ">" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*//\\s*(?:(?:#?region\\b)|(?:<editor-fold\\b))"),
+        end: new RegExp("^\\s*//\\s*(?:(?:#?endregion\\b)|(?:</editor-fold>))")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".kt",
+    keywords: [
+      "as",
+      "as?",
+      "break",
+      "class",
+      "continue",
+      "do",
+      "else",
+      "false",
+      "for",
+      "fun",
+      "if",
+      "in",
+      "!in",
+      "interface",
+      "is",
+      "!is",
+      "null",
+      "object",
+      "package",
+      "return",
+      "super",
+      "this",
+      "throw",
+      "true",
+      "try",
+      "typealias",
+      "val",
+      "var",
+      "when",
+      "while",
+      "by",
+      "catch",
+      "constructor",
+      "delegate",
+      "dynamic",
+      "field",
+      "file",
+      "finally",
+      "get",
+      "import",
+      "init",
+      "param",
+      "property",
+      "receiver",
+      "set",
+      "setparam",
+      "where",
+      "actual",
+      "abstract",
+      "annotation",
+      "companion",
+      "const",
+      "crossinline",
+      "data",
+      "enum",
+      "expect",
+      "external",
+      "final",
+      "infix",
+      "inline",
+      "inner",
+      "internal",
+      "lateinit",
+      "noinline",
+      "open",
+      "operator",
+      "out",
+      "override",
+      "private",
+      "protected",
+      "public",
+      "reified",
+      "sealed",
+      "suspend",
+      "tailrec",
+      "vararg",
+      "field",
+      "it"
+    ],
+    operators: [
+      "+",
+      "-",
+      "*",
+      "/",
+      "%",
+      "=",
+      "+=",
+      "-=",
+      "*=",
+      "/=",
+      "%=",
+      "++",
+      "--",
+      "&&",
+      "||",
+      "!",
+      "==",
+      "!=",
+      "===",
+      "!==",
+      ">",
+      "<",
+      "<=",
+      ">=",
+      "[",
+      "]",
+      "!!",
+      "?.",
+      "?:",
+      "::",
+      "..",
+      ":",
+      "?",
+      "->",
+      "@",
+      ";",
+      "$",
+      "_"
+    ],
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    digits: /\d+(_+\d+)*/,
+    octaldigits: /[0-7]+(_+[0-7]+)*/,
+    binarydigits: /[0-1]+(_+[0-1]+)*/,
+    hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+    tokenizer: {
+      root: [
+        [/[A-Z][\w\$]*/, "type.identifier"],
+        [
+          /[a-zA-Z_$][\w$]*/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@default": "identifier"
+            }
+          }
+        ],
+        { include: "@whitespace" },
+        [/[{}()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "delimiter",
+              "@default": ""
+            }
+          }
+        ],
+        [/@\s*[a-zA-Z_\$][\w\$]*/, "annotation"],
+        [/(@digits)[eE]([\-+]?(@digits))?[fFdD]?/, "number.float"],
+        [/(@digits)\.(@digits)([eE][\-+]?(@digits))?[fFdD]?/, "number.float"],
+        [/0[xX](@hexdigits)[Ll]?/, "number.hex"],
+        [/0(@octaldigits)[Ll]?/, "number.octal"],
+        [/0[bB](@binarydigits)[Ll]?/, "number.binary"],
+        [/(@digits)[fFdD]/, "number.float"],
+        [/(@digits)[lL]?/, "number"],
+        [/[;,.]/, "delimiter"],
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        [/"""/, "string", "@multistring"],
+        [/"/, "string", "@string"],
+        [/'[^\\']'/, "string"],
+        [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+        [/'/, "string.invalid"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/\/\*\*(?!\/)/, "comment.doc", "@javadoc"],
+        [/\/\*/, "comment", "@comment"],
+        [/\/\/.*$/, "comment"]
+      ],
+      comment: [
+        [/[^\/*]+/, "comment"],
+        [/\/\*/, "comment", "@comment"],
+        [/\*\//, "comment", "@pop"],
+        [/[\/*]/, "comment"]
+      ],
+      javadoc: [
+        [/[^\/*]+/, "comment.doc"],
+        [/\/\*/, "comment.doc", "@push"],
+        [/\/\*/, "comment.doc.invalid"],
+        [/\*\//, "comment.doc", "@pop"],
+        [/[\/*]/, "comment.doc"]
+      ],
+      string: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, "string", "@pop"]
+      ],
+      multistring: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"""/, "string", "@pop"],
+        [/./, "string"]
+      ]
+    }
+  };
+  return kotlin_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/less/less.js

@@ -0,0 +1,184 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/less/less",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/less/less.ts
+  var less_exports = {};
+  __export(less_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    wordPattern: /(#?-?\d*\.\d\w*%?)|([@#!.:]?[\w-?]+%?)|[@#!.]/g,
+    comments: {
+      blockComment: ["/*", "*/"],
+      lineComment: "//"
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}", notIn: ["string", "comment"] },
+      { open: "[", close: "]", notIn: ["string", "comment"] },
+      { open: "(", close: ")", notIn: ["string", "comment"] },
+      { open: '"', close: '"', notIn: ["string", "comment"] },
+      { open: "'", close: "'", notIn: ["string", "comment"] }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*\\/\\*\\s*#region\\b\\s*(.*?)\\s*\\*\\/"),
+        end: new RegExp("^\\s*\\/\\*\\s*#endregion\\b.*\\*\\/")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".less",
+    identifier: "-?-?([a-zA-Z]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*",
+    identifierPlus: "-?-?([a-zA-Z:.]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-:.]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*",
+    brackets: [
+      { open: "{", close: "}", token: "delimiter.curly" },
+      { open: "[", close: "]", token: "delimiter.bracket" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" },
+      { open: "<", close: ">", token: "delimiter.angle" }
+    ],
+    tokenizer: {
+      root: [
+        { include: "@nestedJSBegin" },
+        ["[ \\t\\r\\n]+", ""],
+        { include: "@comments" },
+        { include: "@keyword" },
+        { include: "@strings" },
+        { include: "@numbers" },
+        ["[*_]?[a-zA-Z\\-\\s]+(?=:.*(;|(\\\\$)))", "attribute.name", "@attribute"],
+        ["url(\\-prefix)?\\(", { token: "tag", next: "@urldeclaration" }],
+        ["[{}()\\[\\]]", "@brackets"],
+        ["[,:;]", "delimiter"],
+        ["#@identifierPlus", "tag.id"],
+        ["&", "tag"],
+        ["\\.@identifierPlus(?=\\()", "tag.class", "@attribute"],
+        ["\\.@identifierPlus", "tag.class"],
+        ["@identifierPlus", "tag"],
+        { include: "@operators" },
+        ["@(@identifier(?=[:,\\)]))", "variable", "@attribute"],
+        ["@(@identifier)", "variable"],
+        ["@", "key", "@atRules"]
+      ],
+      nestedJSBegin: [
+        ["``", "delimiter.backtick"],
+        [
+          "`",
+          {
+            token: "delimiter.backtick",
+            next: "@nestedJSEnd",
+            nextEmbedded: "text/javascript"
+          }
+        ]
+      ],
+      nestedJSEnd: [
+        [
+          "`",
+          {
+            token: "delimiter.backtick",
+            next: "@pop",
+            nextEmbedded: "@pop"
+          }
+        ]
+      ],
+      operators: [["[<>=\\+\\-\\*\\/\\^\\|\\~]", "operator"]],
+      keyword: [
+        [
+          "(@[\\s]*import|![\\s]*important|true|false|when|iscolor|isnumber|isstring|iskeyword|isurl|ispixel|ispercentage|isem|hue|saturation|lightness|alpha|lighten|darken|saturate|desaturate|fadein|fadeout|fade|spin|mix|round|ceil|floor|percentage)\\b",
+          "keyword"
+        ]
+      ],
+      urldeclaration: [
+        { include: "@strings" },
+        ["[^)\r\n]+", "string"],
+        ["\\)", { token: "tag", next: "@pop" }]
+      ],
+      attribute: [
+        { include: "@nestedJSBegin" },
+        { include: "@comments" },
+        { include: "@strings" },
+        { include: "@numbers" },
+        { include: "@keyword" },
+        ["[a-zA-Z\\-]+(?=\\()", "attribute.value", "@attribute"],
+        [">", "operator", "@pop"],
+        ["@identifier", "attribute.value"],
+        { include: "@operators" },
+        ["@(@identifier)", "variable"],
+        ["[)\\}]", "@brackets", "@pop"],
+        ["[{}()\\[\\]>]", "@brackets"],
+        ["[;]", "delimiter", "@pop"],
+        ["[,=:]", "delimiter"],
+        ["\\s", ""],
+        [".", "attribute.value"]
+      ],
+      comments: [
+        ["\\/\\*", "comment", "@comment"],
+        ["\\/\\/+.*", "comment"]
+      ],
+      comment: [
+        ["\\*\\/", "comment", "@pop"],
+        [".", "comment"]
+      ],
+      numbers: [
+        ["(\\d*\\.)?\\d+([eE][\\-+]?\\d+)?", { token: "attribute.value.number", next: "@units" }],
+        ["#[0-9a-fA-F_]+(?!\\w)", "attribute.value.hex"]
+      ],
+      units: [
+        [
+          "(em|ex|ch|rem|vmin|vmax|vw|vh|vm|cm|mm|in|px|pt|pc|deg|grad|rad|turn|s|ms|Hz|kHz|%)?",
+          "attribute.value.unit",
+          "@pop"
+        ]
+      ],
+      strings: [
+        ['~?"', { token: "string.delimiter", next: "@stringsEndDoubleQuote" }],
+        ["~?'", { token: "string.delimiter", next: "@stringsEndQuote" }]
+      ],
+      stringsEndDoubleQuote: [
+        ['\\\\"', "string"],
+        ['"', { token: "string.delimiter", next: "@popall" }],
+        [".", "string"]
+      ],
+      stringsEndQuote: [
+        ["\\\\'", "string"],
+        ["'", { token: "string.delimiter", next: "@popall" }],
+        [".", "string"]
+      ],
+      atRules: [
+        { include: "@comments" },
+        { include: "@strings" },
+        ["[()]", "delimiter"],
+        ["[\\{;]", "delimiter", "@pop"],
+        [".", "key"]
+      ]
+    }
+  };
+  return less_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/lexon/lexon.js

@@ -0,0 +1,168 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/lexon/lexon",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/lexon/lexon.ts
+  var lexon_exports = {};
+  __export(lexon_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "COMMENT"
+    },
+    brackets: [["(", ")"]],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: ":", close: "." }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "`", close: "`" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: ":", close: "." }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*(::\\s*|COMMENT\\s+)#region"),
+        end: new RegExp("^\\s*(::\\s*|COMMENT\\s+)#endregion")
+      }
+    }
+  };
+  var language = {
+    tokenPostfix: ".lexon",
+    ignoreCase: true,
+    keywords: [
+      "lexon",
+      "lex",
+      "clause",
+      "terms",
+      "contracts",
+      "may",
+      "pay",
+      "pays",
+      "appoints",
+      "into",
+      "to"
+    ],
+    typeKeywords: ["amount", "person", "key", "time", "date", "asset", "text"],
+    operators: [
+      "less",
+      "greater",
+      "equal",
+      "le",
+      "gt",
+      "or",
+      "and",
+      "add",
+      "added",
+      "subtract",
+      "subtracted",
+      "multiply",
+      "multiplied",
+      "times",
+      "divide",
+      "divided",
+      "is",
+      "be",
+      "certified"
+    ],
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    tokenizer: {
+      root: [
+        [/^(\s*)(comment:?(?:\s.*|))$/, ["", "comment"]],
+        [
+          /"/,
+          {
+            token: "identifier.quote",
+            bracket: "@open",
+            next: "@quoted_identifier"
+          }
+        ],
+        [
+          "LEX$",
+          {
+            token: "keyword",
+            bracket: "@open",
+            next: "@identifier_until_period"
+          }
+        ],
+        ["LEXON", { token: "keyword", bracket: "@open", next: "@semver" }],
+        [
+          ":",
+          {
+            token: "delimiter",
+            bracket: "@open",
+            next: "@identifier_until_period"
+          }
+        ],
+        [
+          /[a-z_$][\w$]*/,
+          {
+            cases: {
+              "@operators": "operator",
+              "@typeKeywords": "keyword.type",
+              "@keywords": "keyword",
+              "@default": "identifier"
+            }
+          }
+        ],
+        { include: "@whitespace" },
+        [/[{}()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [/@symbols/, "delimiter"],
+        [/\d*\.\d*\.\d*/, "number.semver"],
+        [/\d*\.\d+([eE][\-+]?\d+)?/, "number.float"],
+        [/0[xX][0-9a-fA-F]+/, "number.hex"],
+        [/\d+/, "number"],
+        [/[;,.]/, "delimiter"]
+      ],
+      quoted_identifier: [
+        [/[^\\"]+/, "identifier"],
+        [/"/, { token: "identifier.quote", bracket: "@close", next: "@pop" }]
+      ],
+      space_identifier_until_period: [
+        [":", "delimiter"],
+        [" ", { token: "white", next: "@identifier_rest" }]
+      ],
+      identifier_until_period: [
+        { include: "@whitespace" },
+        [":", { token: "delimiter", next: "@identifier_rest" }],
+        [/[^\\.]+/, "identifier"],
+        [/\./, { token: "delimiter", bracket: "@close", next: "@pop" }]
+      ],
+      identifier_rest: [
+        [/[^\\.]+/, "identifier"],
+        [/\./, { token: "delimiter", bracket: "@close", next: "@pop" }]
+      ],
+      semver: [
+        { include: "@whitespace" },
+        [":", "delimiter"],
+        [/\d*\.\d*\.\d*/, { token: "number.semver", bracket: "@close", next: "@pop" }]
+      ],
+      whitespace: [[/[ \t\r\n]+/, "white"]]
+    }
+  };
+  return lexon_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/liquid/liquid.js

@@ -0,0 +1,281 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/liquid/liquid",[],()=>{
+var moduleExports = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __reExport = (target, module, desc) => {
+    if (module && typeof module === "object" || typeof module === "function") {
+      for (let key of __getOwnPropNames(module))
+        if (!__hasOwnProp.call(target, key) && key !== "default")
+          __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
+    }
+    return target;
+  };
+  var __toModule = (module) => {
+    return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", module && module.__esModule && "default" in module ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
+  };
+
+  // build/fillers/monaco-editor-core-amd.ts
+  var require_monaco_editor_core_amd = __commonJS({
+    "build/fillers/monaco-editor-core-amd.ts"(exports, module) {
+      module.exports = self.monaco;
+    }
+  });
+
+  // src/basic-languages/liquid/liquid.ts
+  var liquid_exports = {};
+  __export(liquid_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+
+  // src/fillers/monaco-editor-core.ts
+  var monaco_editor_core_exports = {};
+  __markAsModule(monaco_editor_core_exports);
+  __reExport(monaco_editor_core_exports, __toModule(require_monaco_editor_core_amd()));
+
+  // src/basic-languages/liquid/liquid.ts
+  var EMPTY_ELEMENTS = [
+    "area",
+    "base",
+    "br",
+    "col",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "keygen",
+    "link",
+    "menuitem",
+    "meta",
+    "param",
+    "source",
+    "track",
+    "wbr"
+  ];
+  var conf = {
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\$\^\&\*\(\)\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\s]+)/g,
+    brackets: [
+      ["<!--", "-->"],
+      ["<", ">"],
+      ["{{", "}}"],
+      ["{%", "%}"],
+      ["{", "}"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "%", close: "%" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "<", close: ">" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    onEnterRules: [
+      {
+        beforeText: new RegExp(`<(?!(?:${EMPTY_ELEMENTS.join("|")}))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$`, "i"),
+        afterText: /^<\/(\w[\w\d]*)\s*>$/i,
+        action: {
+          indentAction: monaco_editor_core_exports.languages.IndentAction.IndentOutdent
+        }
+      },
+      {
+        beforeText: new RegExp(`<(?!(?:${EMPTY_ELEMENTS.join("|")}))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$`, "i"),
+        action: { indentAction: monaco_editor_core_exports.languages.IndentAction.Indent }
+      }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: "",
+    builtinTags: [
+      "if",
+      "else",
+      "elseif",
+      "endif",
+      "render",
+      "assign",
+      "capture",
+      "endcapture",
+      "case",
+      "endcase",
+      "comment",
+      "endcomment",
+      "cycle",
+      "decrement",
+      "for",
+      "endfor",
+      "include",
+      "increment",
+      "layout",
+      "raw",
+      "endraw",
+      "render",
+      "tablerow",
+      "endtablerow",
+      "unless",
+      "endunless"
+    ],
+    builtinFilters: [
+      "abs",
+      "append",
+      "at_least",
+      "at_most",
+      "capitalize",
+      "ceil",
+      "compact",
+      "date",
+      "default",
+      "divided_by",
+      "downcase",
+      "escape",
+      "escape_once",
+      "first",
+      "floor",
+      "join",
+      "json",
+      "last",
+      "lstrip",
+      "map",
+      "minus",
+      "modulo",
+      "newline_to_br",
+      "plus",
+      "prepend",
+      "remove",
+      "remove_first",
+      "replace",
+      "replace_first",
+      "reverse",
+      "round",
+      "rstrip",
+      "size",
+      "slice",
+      "sort",
+      "sort_natural",
+      "split",
+      "strip",
+      "strip_html",
+      "strip_newlines",
+      "times",
+      "truncate",
+      "truncatewords",
+      "uniq",
+      "upcase",
+      "url_decode",
+      "url_encode",
+      "where"
+    ],
+    constants: ["true", "false"],
+    operators: ["==", "!=", ">", "<", ">=", "<="],
+    symbol: /[=><!]+/,
+    identifier: /[a-zA-Z_][\w]*/,
+    tokenizer: {
+      root: [
+        [/\{\%\s*comment\s*\%\}/, "comment.start.liquid", "@comment"],
+        [/\{\{/, { token: "@rematch", switchTo: "@liquidState.root" }],
+        [/\{\%/, { token: "@rematch", switchTo: "@liquidState.root" }],
+        [/(<)([\w\-]+)(\/>)/, ["delimiter.html", "tag.html", "delimiter.html"]],
+        [/(<)([:\w]+)/, ["delimiter.html", { token: "tag.html", next: "@otherTag" }]],
+        [/(<\/)([\w\-]+)/, ["delimiter.html", { token: "tag.html", next: "@otherTag" }]],
+        [/</, "delimiter.html"],
+        [/\{/, "delimiter.html"],
+        [/[^<{]+/]
+      ],
+      comment: [
+        [/\{\%\s*endcomment\s*\%\}/, "comment.end.liquid", "@pop"],
+        [/./, "comment.content.liquid"]
+      ],
+      otherTag: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@liquidState.otherTag"
+          }
+        ],
+        [
+          /\{\%/,
+          {
+            token: "@rematch",
+            switchTo: "@liquidState.otherTag"
+          }
+        ],
+        [/\/?>/, "delimiter.html", "@pop"],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [/[ \t\r\n]+/]
+      ],
+      liquidState: [
+        [/\{\{/, "delimiter.output.liquid"],
+        [/\}\}/, { token: "delimiter.output.liquid", switchTo: "@$S2.$S3" }],
+        [/\{\%/, "delimiter.tag.liquid"],
+        [/raw\s*\%\}/, "delimiter.tag.liquid", "@liquidRaw"],
+        [/\%\}/, { token: "delimiter.tag.liquid", switchTo: "@$S2.$S3" }],
+        { include: "liquidRoot" }
+      ],
+      liquidRaw: [
+        [/^(?!\{\%\s*endraw\s*\%\}).+/],
+        [/\{\%/, "delimiter.tag.liquid"],
+        [/@identifier/],
+        [/\%\}/, { token: "delimiter.tag.liquid", next: "@root" }]
+      ],
+      liquidRoot: [
+        [/\d+(\.\d+)?/, "number.liquid"],
+        [/"[^"]*"/, "string.liquid"],
+        [/'[^']*'/, "string.liquid"],
+        [/\s+/],
+        [
+          /@symbol/,
+          {
+            cases: {
+              "@operators": "operator.liquid",
+              "@default": ""
+            }
+          }
+        ],
+        [/\./],
+        [
+          /@identifier/,
+          {
+            cases: {
+              "@constants": "keyword.liquid",
+              "@builtinFilters": "predefined.liquid",
+              "@builtinTags": "predefined.liquid",
+              "@default": "variable.liquid"
+            }
+          }
+        ],
+        [/[^}|%]/, "variable.liquid"]
+      ]
+    }
+  };
+  return liquid_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/lua/lua.js

@@ -0,0 +1,174 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/lua/lua",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/lua/lua.ts
+  var lua_exports = {};
+  __export(lua_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "--",
+      blockComment: ["--[[", "]]"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".lua",
+    keywords: [
+      "and",
+      "break",
+      "do",
+      "else",
+      "elseif",
+      "end",
+      "false",
+      "for",
+      "function",
+      "goto",
+      "if",
+      "in",
+      "local",
+      "nil",
+      "not",
+      "or",
+      "repeat",
+      "return",
+      "then",
+      "true",
+      "until",
+      "while"
+    ],
+    brackets: [
+      { token: "delimiter.bracket", open: "{", close: "}" },
+      { token: "delimiter.array", open: "[", close: "]" },
+      { token: "delimiter.parenthesis", open: "(", close: ")" }
+    ],
+    operators: [
+      "+",
+      "-",
+      "*",
+      "/",
+      "%",
+      "^",
+      "#",
+      "==",
+      "~=",
+      "<=",
+      ">=",
+      "<",
+      ">",
+      "=",
+      ";",
+      ":",
+      ",",
+      ".",
+      "..",
+      "..."
+    ],
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    tokenizer: {
+      root: [
+        [
+          /[a-zA-Z_]\w*/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@default": "identifier"
+            }
+          }
+        ],
+        { include: "@whitespace" },
+        [/(,)(\s*)([a-zA-Z_]\w*)(\s*)(:)(?!:)/, ["delimiter", "", "key", "", "delimiter"]],
+        [/({)(\s*)([a-zA-Z_]\w*)(\s*)(:)(?!:)/, ["@brackets", "", "key", "", "delimiter"]],
+        [/[{}()\[\]]/, "@brackets"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "delimiter",
+              "@default": ""
+            }
+          }
+        ],
+        [/\d*\.\d+([eE][\-+]?\d+)?/, "number.float"],
+        [/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/, "number.hex"],
+        [/\d+?/, "number"],
+        [/[;,.]/, "delimiter"],
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        [/'([^'\\]|\\.)*$/, "string.invalid"],
+        [/"/, "string", '@string."'],
+        [/'/, "string", "@string.'"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/--\[([=]*)\[/, "comment", "@comment.$1"],
+        [/--.*$/, "comment"]
+      ],
+      comment: [
+        [/[^\]]+/, "comment"],
+        [
+          /\]([=]*)\]/,
+          {
+            cases: {
+              "$1==$S2": { token: "comment", next: "@pop" },
+              "@default": "comment"
+            }
+          }
+        ],
+        [/./, "comment"]
+      ],
+      string: [
+        [/[^\\"']+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [
+          /["']/,
+          {
+            cases: {
+              "$#==$S2": { token: "string", next: "@pop" },
+              "@default": "string"
+            }
+          }
+        ]
+      ]
+    }
+  };
+  return lua_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/m3/m3.js

@@ -0,0 +1,227 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/m3/m3",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/m3/m3.ts
+  var m3_exports = {};
+  __export(m3_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      blockComment: ["(*", "*)"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "[", close: "]" },
+      { open: "{", close: "}" },
+      { open: "(", close: ")" },
+      { open: "(*", close: "*)" },
+      { open: "<*", close: "*>" },
+      { open: "'", close: "'", notIn: ["string", "comment"] },
+      { open: '"', close: '"', notIn: ["string", "comment"] }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".m3",
+    brackets: [
+      { token: "delimiter.curly", open: "{", close: "}" },
+      { token: "delimiter.parenthesis", open: "(", close: ")" },
+      { token: "delimiter.square", open: "[", close: "]" }
+    ],
+    keywords: [
+      "AND",
+      "ANY",
+      "ARRAY",
+      "AS",
+      "BEGIN",
+      "BITS",
+      "BRANDED",
+      "BY",
+      "CASE",
+      "CONST",
+      "DIV",
+      "DO",
+      "ELSE",
+      "ELSIF",
+      "END",
+      "EVAL",
+      "EXCEPT",
+      "EXCEPTION",
+      "EXIT",
+      "EXPORTS",
+      "FINALLY",
+      "FOR",
+      "FROM",
+      "GENERIC",
+      "IF",
+      "IMPORT",
+      "IN",
+      "INTERFACE",
+      "LOCK",
+      "LOOP",
+      "METHODS",
+      "MOD",
+      "MODULE",
+      "NOT",
+      "OBJECT",
+      "OF",
+      "OR",
+      "OVERRIDES",
+      "PROCEDURE",
+      "RAISE",
+      "RAISES",
+      "READONLY",
+      "RECORD",
+      "REF",
+      "REPEAT",
+      "RETURN",
+      "REVEAL",
+      "SET",
+      "THEN",
+      "TO",
+      "TRY",
+      "TYPE",
+      "TYPECASE",
+      "UNSAFE",
+      "UNTIL",
+      "UNTRACED",
+      "VALUE",
+      "VAR",
+      "WHILE",
+      "WITH"
+    ],
+    reservedConstNames: [
+      "ABS",
+      "ADR",
+      "ADRSIZE",
+      "BITSIZE",
+      "BYTESIZE",
+      "CEILING",
+      "DEC",
+      "DISPOSE",
+      "FALSE",
+      "FIRST",
+      "FLOAT",
+      "FLOOR",
+      "INC",
+      "ISTYPE",
+      "LAST",
+      "LOOPHOLE",
+      "MAX",
+      "MIN",
+      "NARROW",
+      "NEW",
+      "NIL",
+      "NUMBER",
+      "ORD",
+      "ROUND",
+      "SUBARRAY",
+      "TRUE",
+      "TRUNC",
+      "TYPECODE",
+      "VAL"
+    ],
+    reservedTypeNames: [
+      "ADDRESS",
+      "ANY",
+      "BOOLEAN",
+      "CARDINAL",
+      "CHAR",
+      "EXTENDED",
+      "INTEGER",
+      "LONGCARD",
+      "LONGINT",
+      "LONGREAL",
+      "MUTEX",
+      "NULL",
+      "REAL",
+      "REFANY",
+      "ROOT",
+      "TEXT"
+    ],
+    operators: ["+", "-", "*", "/", "&", "^", "."],
+    relations: ["=", "#", "<", "<=", ">", ">=", "<:", ":"],
+    delimiters: ["|", "..", "=>", ",", ";", ":="],
+    symbols: /[>=<#.,:;+\-*/&^]+/,
+    escapes: /\\(?:[\\fnrt"']|[0-7]{3})/,
+    tokenizer: {
+      root: [
+        [/_\w*/, "invalid"],
+        [
+          /[a-zA-Z][a-zA-Z0-9_]*/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@reservedConstNames": { token: "constant.reserved.$0" },
+              "@reservedTypeNames": { token: "type.reserved.$0" },
+              "@default": "identifier"
+            }
+          }
+        ],
+        { include: "@whitespace" },
+        [/[{}()\[\]]/, "@brackets"],
+        [/[0-9]+\.[0-9]+(?:[DdEeXx][\+\-]?[0-9]+)?/, "number.float"],
+        [/[0-9]+(?:\_[0-9a-fA-F]+)?L?/, "number"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "operators",
+              "@relations": "operators",
+              "@delimiters": "delimiter",
+              "@default": "invalid"
+            }
+          }
+        ],
+        [/'[^\\']'/, "string.char"],
+        [/(')(@escapes)(')/, ["string.char", "string.escape", "string.char"]],
+        [/'/, "invalid"],
+        [/"([^"\\]|\\.)*$/, "invalid"],
+        [/"/, "string.text", "@text"]
+      ],
+      text: [
+        [/[^\\"]+/, "string.text"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "invalid"],
+        [/"/, "string.text", "@pop"]
+      ],
+      comment: [
+        [/\(\*/, "comment", "@push"],
+        [/\*\)/, "comment", "@pop"],
+        [/./, "comment"]
+      ],
+      pragma: [
+        [/<\*/, "keyword.pragma", "@push"],
+        [/\*>/, "keyword.pragma", "@pop"],
+        [/./, "keyword.pragma"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, "white"],
+        [/\(\*/, "comment", "@comment"],
+        [/<\*/, "keyword.pragma", "@pragma"]
+      ]
+    }
+  };
+  return m3_exports;
+})();
+return moduleExports;
+});

assets/monaco-editor/dev/vs/basic-languages/markdown/markdown.js

@@ -0,0 +1,219 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.31.1(337587859b1c171314b40503171188b6cea6a32a)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/markdown/markdown",[],()=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/basic-languages/markdown/markdown.ts
+  var markdown_exports = {};
+  __export(markdown_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      blockComment: ["<!--", "-->"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "<", close: ">", notIn: ["string"] }
+    ],
+    surroundingPairs: [
+      { open: "(", close: ")" },
+      { open: "[", close: "]" },
+      { open: "`", close: "`" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*<!--\\s*#?region\\b.*-->"),
+        end: new RegExp("^\\s*<!--\\s*#?endregion\\b.*-->")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".md",
+    control: /[\\`*_\[\]{}()#+\-\.!]/,
+    noncontrol: /[^\\`*_\[\]{}()#+\-\.!]/,
+    escapes: /\\(?:@control)/,
+    jsescapes: /\\(?:[btnfr\\"']|[0-7][0-7]?|[0-3][0-7]{2})/,
+    empty: [
+      "area",
+      "base",
+      "basefont",
+      "br",
+      "col",
+      "frame",
+      "hr",
+      "img",
+      "input",
+      "isindex",
+      "link",
+      "meta",
+      "param"
+    ],
+    tokenizer: {
+      root: [
+        [/^\s*\|/, "@rematch", "@table_header"],
+        [/^(\s{0,3})(#+)((?:[^\\#]|@escapes)+)((?:#+)?)/, ["white", "keyword", "keyword", "keyword"]],
+        [/^\s*(=+|\-+)\s*$/, "keyword"],
+        [/^\s*((\*[ ]?)+)\s*$/, "meta.separator"],
+        [/^\s*>+/, "comment"],
+        [/^\s*([\*\-+:]|\d+\.)\s/, "keyword"],
+        [/^(\t|[ ]{4})[^ ].*$/, "string"],
+        [/^\s*~~~\s*((?:\w|[\/\-#])+)?\s*$/, { token: "string", next: "@codeblock" }],
+        [
+          /^\s*```\s*((?:\w|[\/\-#])+).*$/,
+          { token: "string", next: "@codeblockgh", nextEmbedded: "$1" }
+        ],
+        [/^\s*```\s*$/, { token: "string", next: "@codeblock" }],
+        { include: "@linecontent" }
+      ],
+      table_header: [
+        { include: "@table_common" },
+        [/[^\|]+/, "keyword.table.header"]
+      ],
+      table_body: [{ include: "@table_common" }, { include: "@linecontent" }],
+      table_common: [
+        [/\s*[\-:]+\s*/, { token: "keyword", switchTo: "table_body" }],
+        [/^\s*\|/, "keyword.table.left"],
+        [/^\s*[^\|]/, "@rematch", "@pop"],
+        [/^\s*$/, "@rematch", "@pop"],
+        [
+          /\|/,
+          {
+            cases: {
+              "@eos": "keyword.table.right",
+              "@default": "keyword.table.middle"
+            }
+          }
+        ]
+      ],
+      codeblock: [
+        [/^\s*~~~\s*$/, { token: "string", next: "@pop" }],
+        [/^\s*```\s*$/, { token: "string", next: "@pop" }],
+        [/.*$/, "variable.source"]
+      ],
+      codeblockgh: [
+        [/```\s*$/, { token: "string", next: "@pop", nextEmbedded: "@pop" }],
+        [/[^`]+/, "variable.source"]
+      ],
+      linecontent: [
+        [/&\w+;/, "string.escape"],
+        [/@escapes/, "escape"],
+        [/\b__([^\\_]|@escapes|_(?!_))+__\b/, "strong"],
+        [/\*\*([^\\*]|@escapes|\*(?!\*))+\*\*/, "strong"],
+        [/\b_[^_]+_\b/, "emphasis"],
+        [/\*([^\\*]|@escapes)+\*/, "emphasis"],
+        [/`([^\\`]|@escapes)+`/, "variable"],
+        [/\{+[^}]+\}+/, "string.target"],
+        [/(!?\[)((?:[^\]\\]|@escapes)*)(\]\([^\)]+\))/, ["string.link", "", "string.link"]],
+        [/(!?\[)((?:[^\]\\]|@escapes)*)(\])/, "string.link"],
+        { include: "html" }
+      ],
+      html: [
+        [/<(\w+)\/>/, "tag"],
+        [
+          /<(\w+)/,
+          {
+            cases: {
+              "@empty": { token: "tag", next: "@tag.$1" },
+              "@default": { token: "tag", next: "@tag.$1" }
+            }
+          }
+        ],
+        [/<\/(\w+)\s*>/, { token: "tag" }],
+        [/<!--/, "comment", "@comment"]
+      ],
+      comment: [
+        [/[^<\-]+/, "comment.content"],
+        [/-->/, "comment", "@pop"],
+        [/<!--/, "comment.content.invalid"],
+        [/[<\-]/, "comment.content"]
+      ],
+      tag: [
+        [/[ \t\r\n]+/, "white"],
+        [
+          /(type)(\s*=\s*)(")([^"]+)(")/,
+          [
+            "attribute.name.html",
+            "delimiter.html",
+            "string.html",
+            { token: "string.html", switchTo: "@tag.$S2.$4" },
+            "string.html"
+          ]
+        ],
+        [
+          /(type)(\s*=\s*)(')([^']+)(')/,
+          [
+            "attribute.name.html",
+            "delimiter.html",
+            "string.html",
+            { token: "string.html", switchTo: "@tag.$S2.$4" },
+            "string.html"
+          ]
+        ],
+        [/(\w+)(\s*=\s*)("[^"]*"|'[^']*')/, ["attribute.name.html", "delimiter.html", "string.html"]],
+        [/\w+/, "attribute.name.html"],
+        [/\/>/, "tag", "@pop"],
+        [
+          />/,
+          {
+            cases: {
+              "$S2==style": {
+                token: "tag",
+                switchTo: "embeddedStyle",
+                nextEmbedded: "text/css"
+              },
+              "$S2==script": {
+                cases: {
+                  $S3: {
+                    token: "tag",
+                    switchTo: "embeddedScript",
+                    nextEmbedded: "$S3"
+                  },
+                  "@default": {
+                    token: "tag",
+                    switchTo: "embeddedScript",
+                    nextEmbedded: "text/javascript"
+                  }
+                }
+              },
+              "@default": { token: "tag", next: "@pop" }
+            }
+          }
+        ]
+      ],
+      embeddedStyle: [
+        [/[^<]+/, ""],
+        [/<\/style\s*>/, { token: "@rematch", next: "@pop", nextEmbedded: "@pop" }],
+        [/</, ""]
+      ],
+      embeddedScript: [
+        [/[^<]+/, ""],
+        [/<\/script\s*>/, { token: "@rematch", next: "@pop", nextEmbedded: "@pop" }],
+        [/</, ""]
+      ]
+    }
+  };
+  return markdown_exports;
+})();
+return moduleExports;
+});