@glodon-aiot/react-components 3.3.0-beta.17 → 3.3.0-beta.19

package/dist/es/node_modules/refractor/lang/gml.mjs

@@ -1,19 +0,0 @@
-var t, i;
-function r() {
-  if (i)
-    return t;
-  i = 1, t = e, e.displayName = "gml", e.aliases = [];
-  function e(o) {
-    o.languages.gamemakerlanguage = o.languages.gml = o.languages.extend("clike", {
-      keyword: /\b(?:break|case|continue|default|do|else|enum|exit|for|globalvar|if|repeat|return|switch|until|var|while)\b/,
-      number: /(?:\b0x[\da-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ulf]{0,4}/i,
-      operator: /--|\+\+|[-+%/=]=?|!=|\*\*?=?|<[<=>]?|>[=>]?|&&?|\^\^?|\|\|?|~|\b(?:and|at|not|or|with|xor)\b/,
-      constant: /\b(?:GM_build_date|GM_version|action_(?:continue|restart|reverse|stop)|all|gamespeed_(?:fps|microseconds)|global|local|noone|other|pi|pointer_(?:invalid|null)|self|timezone_(?:local|utc)|undefined|ev_(?:create|destroy|step|alarm|keyboard|mouse|collision|other|draw|draw_(?:begin|end|post|pre)|keypress|keyrelease|trigger|(?:left|middle|no|right)_button|(?:left|middle|right)_press|(?:left|middle|right)_release|mouse_(?:enter|leave|wheel_down|wheel_up)|global_(?:left|middle|right)_button|global_(?:left|middle|right)_press|global_(?:left|middle|right)_release|joystick(?:1|2)_(?:button1|button2|button3|button4|button5|button6|button7|button8|down|left|right|up)|outside|boundary|game_start|game_end|room_start|room_end|no_more_lives|animation_end|end_of_path|no_more_health|user\d|gui|gui_begin|gui_end|step_(?:begin|end|normal))|vk_(?:alt|anykey|backspace|control|delete|down|end|enter|escape|home|insert|left|nokey|pagedown|pageup|pause|printscreen|return|right|shift|space|tab|up|f\d|numpad\d|add|decimal|divide|lalt|lcontrol|lshift|multiply|ralt|rcontrol|rshift|subtract)|achievement_(?:filter_(?:all_players|favorites_only|friends_only)|friends_info|info|leaderboard_info|our_info|pic_loaded|show_(?:achievement|bank|friend_picker|leaderboard|profile|purchase_prompt|ui)|type_challenge|type_score_challenge)|asset_(?:font|object|path|room|script|shader|sound|sprite|tiles|timeline|unknown)|audio_(?:3d|falloff_(?:exponent_distance|exponent_distance_clamped|inverse_distance|inverse_distance_clamped|linear_distance|linear_distance_clamped|none)|mono|new_system|old_system|stereo)|bm_(?:add|complex|dest_alpha|dest_color|dest_colour|inv_dest_alpha|inv_dest_color|inv_dest_colour|inv_src_alpha|inv_src_color|inv_src_colour|max|normal|one|src_alpha|src_alpha_sat|src_color|src_colour|subtract|zero)|browser_(?:chrome|firefox|ie|ie_mobile|not_a_browser|opera|safari|safari_mobile|tizen|unknown|windows_store)|buffer_(?:bool|f16|f32|f64|fast|fixed|generalerror|grow|invalidtype|network|outofbounds|outofspace|s16|s32|s8|seek_end|seek_relative|seek_start|string|text|u16|u32|u64|u8|vbuffer|wrap)|c_(?:aqua|black|blue|dkgray|fuchsia|gray|green|lime|ltgray|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow)|cmpfunc_(?:always|equal|greater|greaterequal|less|lessequal|never|notequal)|cr_(?:appstart|arrow|beam|cross|default|drag|handpoint|hourglass|none|size_all|size_nesw|size_ns|size_nwse|size_we|uparrow)|cull_(?:clockwise|counterclockwise|noculling)|device_(?:emulator|tablet)|device_ios_(?:ipad|ipad_retina|iphone|iphone5|iphone6|iphone6plus|iphone_retina|unknown)|display_(?:landscape|landscape_flipped|portrait|portrait_flipped)|dll_(?:cdecl|cdel|stdcall)|ds_type_(?:grid|list|map|priority|queue|stack)|ef_(?:cloud|ellipse|explosion|firework|flare|rain|ring|smoke|smokeup|snow|spark|star)|fa_(?:archive|bottom|center|directory|hidden|left|middle|readonly|right|sysfile|top|volumeid)|fb_login_(?:default|fallback_to_webview|forcing_safari|forcing_webview|no_fallback_to_webview|use_system_account)|iap_(?:available|canceled|ev_consume|ev_product|ev_purchase|ev_restore|ev_storeload|failed|purchased|refunded|status_available|status_loading|status_processing|status_restoring|status_unavailable|status_uninitialised|storeload_failed|storeload_ok|unavailable)|leaderboard_type_(?:number|time_mins_secs)|lighttype_(?:dir|point)|matrix_(?:projection|view|world)|mb_(?:any|left|middle|none|right)|network_(?:config_(?:connect_timeout|disable_reliable_udp|enable_reliable_udp|use_non_blocking_socket)|socket_(?:bluetooth|tcp|udp)|type_(?:connect|data|disconnect|non_blocking_connect))|of_challenge_(?:lose|tie|win)|os_(?:android|ios|linux|macosx|ps3|ps4|psvita|unknown|uwp|win32|win8native|windows|winphone|xboxone)|phy_debug_render_(?:aabb|collision_pairs|coms|core_shapes|joints|obb|shapes)|phy_joint_(?:anchor_1_x|anchor_1_y|anchor_2_x|anchor_2_y|angle|angle_limits|damping_ratio|frequency|length_1|length_2|lower_angle_limit|max_force|max_length|max_motor_force|max_motor_torque|max_torque|motor_force|motor_speed|motor_torque|reaction_force_x|reaction_force_y|reaction_torque|speed|translation|upper_angle_limit)|phy_particle_data_flag_(?:category|color|colour|position|typeflags|velocity)|phy_particle_flag_(?:colormixing|colourmixing|elastic|powder|spring|tensile|viscous|wall|water|zombie)|phy_particle_group_flag_(?:rigid|solid)|pr_(?:linelist|linestrip|pointlist|trianglefan|trianglelist|trianglestrip)|ps_(?:distr|shape)_(?:diamond|ellipse|gaussian|invgaussian|line|linear|rectangle)|pt_shape_(?:circle|cloud|disk|explosion|flare|line|pixel|ring|smoke|snow|spark|sphere|square|star)|ty_(?:real|string)|gp_(?:face\d|axislh|axislv|axisrh|axisrv|padd|padl|padr|padu|select|shoulderl|shoulderlb|shoulderr|shoulderrb|start|stickl|stickr)|lb_disp_(?:none|numeric|time_ms|time_sec)|lb_sort_(?:ascending|descending|none)|ov_(?:achievements|community|friends|gamegroup|players|settings)|ugc_(?:filetype_(?:community|microtrans)|list_(?:Favorited|Followed|Published|Subscribed|UsedOrPlayed|VotedDown|VotedOn|VotedUp|WillVoteLater)|match_(?:AllGuides|Artwork|Collections|ControllerBindings|IntegratedGuides|Items|Items_Mtx|Items_ReadyToUse|Screenshots|UsableInGame|Videos|WebGuides)|query_(?:AcceptedForGameRankedByAcceptanceDate|CreatedByFriendsRankedByPublicationDate|FavoritedByFriendsRankedByPublicationDate|NotYetRated)|query_RankedBy(?:NumTimesReported|PublicationDate|TextSearch|TotalVotesAsc|Trend|Vote|VotesUp)|result_success|sortorder_CreationOrder(?:Asc|Desc)|sortorder_(?:ForModeration|LastUpdatedDesc|SubscriptionDateDesc|TitleAsc|VoteScoreDesc)|visibility_(?:friends_only|private|public))|vertex_usage_(?:binormal|blendindices|blendweight|color|colour|depth|fog|normal|position|psize|sample|tangent|texcoord|textcoord)|vertex_type_(?:float\d|color|colour|ubyte4)|input_type|layerelementtype_(?:background|instance|oldtilemap|particlesystem|sprite|tile|tilemap|undefined)|se_(?:chorus|compressor|echo|equalizer|flanger|gargle|none|reverb)|text_type|tile_(?:flip|index_mask|mirror|rotate)|(?:obj|rm|scr|spr)\w+)\b/,
-      variable: /\b(?:alarm|application_surface|async_load|background_(?:alpha|blend|color|colour|foreground|height|hspeed|htiled|index|showcolor|showcolour|visible|vspeed|vtiled|width|x|xscale|y|yscale)|bbox_(?:bottom|left|right|top)|browser_(?:height|width)|caption_(?:health|lives|score)|current_(?:day|hour|minute|month|second|time|weekday|year)|cursor_sprite|debug_mode|delta_time|direction|display_aa|error_(?:last|occurred)|event_(?:action|number|object|type)|fps|fps_real|friction|game_(?:display|project|save)_(?:id|name)|gamemaker_(?:pro|registered|version)|gravity|gravity_direction|(?:h|v)speed|health|iap_data|id|image_(?:alpha|angle|blend|depth|index|number|speed|xscale|yscale)|instance_(?:count|id)|keyboard_(?:key|lastchar|lastkey|string)|layer|lives|mask_index|mouse_(?:button|lastbutton|x|y)|object_index|os_(?:browser|device|type|version)|path_(?:endaction|index|orientation|position|positionprevious|scale|speed)|persistent|phy_(?:rotation|(?:col_normal|collision|com|linear_velocity|position|speed)_(?:x|y)|angular_(?:damping|velocity)|position_(?:x|y)previous|speed|linear_damping|bullet|fixed_rotation|active|mass|inertia|dynamic|kinematic|sleeping|collision_points)|pointer_(?:invalid|null)|room|room_(?:caption|first|height|last|persistent|speed|width)|score|secure_mode|show_(?:health|lives|score)|solid|speed|sprite_(?:height|index|width|xoffset|yoffset)|temp_directory|timeline_(?:index|loop|position|running|speed)|transition_(?:color|kind|steps)|undefined|view_(?:angle|current|enabled|(?:h|v)(?:border|speed)|(?:h|w|x|y)port|(?:h|w|x|y)view|object|surface_id|visible)|visible|webgl_enabled|working_directory|(?:x|y)(?:previous|start)|x|y|argument(?:_relitive|_count|\d)|argument|global|local|other|self)\b/
-    });
-  }
-  return t;
-}
-export {
-  r as __require
-};

package/dist/es/node_modules/refractor/lang/gn.mjs

@@ -1,55 +0,0 @@
-var t, r;
-function i() {
-  if (r)
-    return t;
-  r = 1, t = e, e.displayName = "gn", e.aliases = ["gni"];
-  function e(n) {
-    n.languages.gn = {
-      comment: {
-        pattern: /#.*/,
-        greedy: !0
-      },
-      "string-literal": {
-        pattern: /(^|[^\\"])"(?:[^\r\n"\\]|\\.)*"/,
-        lookbehind: !0,
-        greedy: !0,
-        inside: {
-          interpolation: {
-            pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:\{[\s\S]*?\}|[a-zA-Z_]\w*|0x[a-fA-F0-9]{2})/,
-            lookbehind: !0,
-            inside: {
-              number: /^\$0x[\s\S]{2}$/,
-              variable: /^\$\w+$/,
-              "interpolation-punctuation": {
-                pattern: /^\$\{|\}$/,
-                alias: "punctuation"
-              },
-              expression: {
-                pattern: /[\s\S]+/,
-                inside: null
-                // see below
-              }
-            }
-          },
-          string: /[\s\S]+/
-        }
-      },
-      keyword: /\b(?:else|if)\b/,
-      boolean: /\b(?:false|true)\b/,
-      "builtin-function": {
-        // a few functions get special highlighting to improve readability
-        pattern: /\b(?:assert|defined|foreach|import|pool|print|template|tool|toolchain)(?=\s*\()/i,
-        alias: "keyword"
-      },
-      function: /\b[a-z_]\w*(?=\s*\()/i,
-      constant: /\b(?:current_cpu|current_os|current_toolchain|default_toolchain|host_cpu|host_os|root_build_dir|root_gen_dir|root_out_dir|target_cpu|target_gen_dir|target_os|target_out_dir)\b/,
-      number: /-?\b\d+\b/,
-      operator: /[-+!=<>]=?|&&|\|\|/,
-      punctuation: /[(){}[\],.]/
-    }, n.languages.gn["string-literal"].inside.interpolation.inside.expression.inside = n.languages.gn, n.languages.gni = n.languages.gn;
-  }
-  return t;
-}
-export {
-  i as __require
-};

package/dist/es/node_modules/refractor/lang/go-module.mjs

@@ -1,34 +0,0 @@
-var o, u;
-function a() {
-  if (u)
-    return o;
-  u = 1, o = e, e.displayName = "goModule", e.aliases = [];
-  function e(r) {
-    r.languages["go-mod"] = r.languages["go-module"] = {
-      comment: {
-        pattern: /\/\/.*/,
-        greedy: !0
-      },
-      version: {
-        pattern: /(^|[\s()[\],])v\d+\.\d+\.\d+(?:[+-][-+.\w]*)?(?![^\s()[\],])/,
-        lookbehind: !0,
-        alias: "number"
-      },
-      "go-version": {
-        pattern: /((?:^|\s)go\s+)\d+(?:\.\d+){1,2}/,
-        lookbehind: !0,
-        alias: "number"
-      },
-      keyword: {
-        pattern: /^([ \t]*)(?:exclude|go|module|replace|require|retract)\b/m,
-        lookbehind: !0
-      },
-      operator: /=>/,
-      punctuation: /[()[\],]/
-    };
-  }
-  return o;
-}
-export {
-  a as __require
-};

package/dist/es/node_modules/refractor/lang/go.mjs

@@ -1,36 +0,0 @@
-var a, n;
-function t() {
-  if (n)
-    return a;
-  n = 1, a = r, r.displayName = "go", r.aliases = [];
-  function r(e) {
-    e.languages.go = e.languages.extend("clike", {
-      string: {
-        pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"|`[^`]*`/,
-        lookbehind: !0,
-        greedy: !0
-      },
-      keyword: /\b(?:break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go(?:to)?|if|import|interface|map|package|range|return|select|struct|switch|type|var)\b/,
-      boolean: /\b(?:_|false|iota|nil|true)\b/,
-      number: [
-        // binary and octal integers
-        /\b0(?:b[01_]+|o[0-7_]+)i?\b/i,
-        // hexadecimal integers and floats
-        /\b0x(?:[a-f\d_]+(?:\.[a-f\d_]*)?|\.[a-f\d_]+)(?:p[+-]?\d+(?:_\d+)*)?i?(?!\w)/i,
-        // decimal integers and floats
-        /(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?[\d_]+)?i?(?!\w)/i
-      ],
-      operator: /[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\./,
-      builtin: /\b(?:append|bool|byte|cap|close|complex|complex(?:64|128)|copy|delete|error|float(?:32|64)|u?int(?:8|16|32|64)?|imag|len|make|new|panic|print(?:ln)?|real|recover|rune|string|uintptr)\b/
-    }), e.languages.insertBefore("go", "string", {
-      char: {
-        pattern: /'(?:\\.|[^'\\\r\n]){0,10}'/,
-        greedy: !0
-      }
-    }), delete e.languages.go["class-name"];
-  }
-  return a;
-}
-export {
-  t as __require
-};

package/dist/es/node_modules/refractor/lang/graphql.mjs

@@ -1,133 +0,0 @@
-var y, A;
-function z() {
-  if (A)
-    return y;
-  A = 1, y = u, u.displayName = "graphql", u.aliases = [];
-  function u(s) {
-    s.languages.graphql = {
-      comment: /#.*/,
-      description: {
-        pattern: /(?:"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*")(?=\s*[a-z_])/i,
-        greedy: !0,
-        alias: "string",
-        inside: {
-          "language-markdown": {
-            pattern: /(^"(?:"")?)(?!\1)[\s\S]+(?=\1$)/,
-            lookbehind: !0,
-            inside: s.languages.markdown
-          }
-        }
-      },
-      string: {
-        pattern: /"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*"/,
-        greedy: !0
-      },
-      number: /(?:\B-|\b)\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
-      boolean: /\b(?:false|true)\b/,
-      variable: /\$[a-z_]\w*/i,
-      directive: {
-        pattern: /@[a-z_]\w*/i,
-        alias: "function"
-      },
-      "attr-name": {
-        pattern: /\b[a-z_]\w*(?=\s*(?:\((?:[^()"]|"(?:\\.|[^\\"\r\n])*")*\))?:)/i,
-        greedy: !0
-      },
-      "atom-input": {
-        pattern: /\b[A-Z]\w*Input\b/,
-        alias: "class-name"
-      },
-      scalar: /\b(?:Boolean|Float|ID|Int|String)\b/,
-      constant: /\b[A-Z][A-Z_\d]*\b/,
-      "class-name": {
-        pattern: /(\b(?:enum|implements|interface|on|scalar|type|union)\s+|&\s*|:\s*|\[)[A-Z_]\w*/,
-        lookbehind: !0
-      },
-      fragment: {
-        pattern: /(\bfragment\s+|\.{3}\s*(?!on\b))[a-zA-Z_]\w*/,
-        lookbehind: !0,
-        alias: "function"
-      },
-      "definition-mutation": {
-        pattern: /(\bmutation\s+)[a-zA-Z_]\w*/,
-        lookbehind: !0,
-        alias: "function"
-      },
-      "definition-query": {
-        pattern: /(\bquery\s+)[a-zA-Z_]\w*/,
-        lookbehind: !0,
-        alias: "function"
-      },
-      keyword: /\b(?:directive|enum|extend|fragment|implements|input|interface|mutation|on|query|repeatable|scalar|schema|subscription|type|union)\b/,
-      operator: /[!=|&]|\.{3}/,
-      "property-query": /\w+(?=\s*\()/,
-      object: /\w+(?=\s*\{)/,
-      punctuation: /[!(){}\[\]:=,]/,
-      property: /\w+/
-    }, s.hooks.add("after-tokenize", function(m) {
-      if (m.language !== "graphql")
-        return;
-      var i = m.tokens.filter(function(t) {
-        return typeof t != "string" && t.type !== "comment" && t.type !== "scalar";
-      }), a = 0;
-      function o(t) {
-        return i[a + t];
-      }
-      function h(t, r) {
-        r = r || 0;
-        for (var e = 0; e < t.length; e++) {
-          var n = o(e + r);
-          if (!n || n.type !== t[e])
-            return !1;
-        }
-        return !0;
-      }
-      function v(t, r) {
-        for (var e = 1, n = a; n < i.length; n++) {
-          var _ = i[n], d = _.content;
-          if (_.type === "punctuation" && typeof d == "string") {
-            if (t.test(d))
-              e++;
-            else if (r.test(d) && (e--, e === 0))
-              return n;
-          }
-        }
-        return -1;
-      }
-      function l(t, r) {
-        var e = t.alias;
-        e ? Array.isArray(e) || (t.alias = e = [e]) : t.alias = e = [], e.push(r);
-      }
-      for (; a < i.length; ) {
-        var q = i[a++];
-        if (q.type === "keyword" && q.content === "mutation") {
-          var p = [];
-          if (h(["definition-mutation", "punctuation"]) && o(1).content === "(") {
-            a += 2;
-            var f = v(/^\($/, /^\)$/);
-            if (f === -1)
-              continue;
-            for (; a < f; a++) {
-              var c = o(0);
-              c.type === "variable" && (l(c, "variable-input"), p.push(c.content));
-            }
-            a = f + 1;
-          }
-          if (h(["punctuation", "property-query"]) && o(0).content === "{" && (a++, l(o(0), "property-mutation"), p.length > 0)) {
-            var w = v(/^\{$/, /^\}$/);
-            if (w === -1)
-              continue;
-            for (var b = a; b < w; b++) {
-              var g = i[b];
-              g.type === "variable" && p.indexOf(g.content) >= 0 && l(g, "variable-input");
-            }
-          }
-        }
-      }
-    });
-  }
-  return y;
-}
-export {
-  z as __require
-};

package/dist/es/node_modules/refractor/lang/groovy.mjs

@@ -1,58 +0,0 @@
-var o, i;
-function s() {
-  if (i)
-    return o;
-  i = 1, o = a, a.displayName = "groovy", a.aliases = [];
-  function a(e) {
-    e.languages.groovy = e.languages.extend("clike", {
-      string: [{
-        // https://groovy-lang.org/syntax.html#_dollar_slashy_string
-        pattern: /("""|''')(?:[^\\]|\\[\s\S])*?\1|\$\/(?:[^/$]|\$(?:[/$]|(?![/$]))|\/(?!\$))*\/\$/,
-        greedy: !0
-      }, {
-        // TODO: Slash strings (e.g. /foo/) can contain line breaks but this will cause a lot of trouble with
-        // simple division (see JS regex), so find a fix maybe?
-        pattern: /(["'/])(?:\\.|(?!\1)[^\\\r\n])*\1/,
-        greedy: !0
-      }],
-      keyword: /\b(?:abstract|as|assert|boolean|break|byte|case|catch|char|class|const|continue|def|default|do|double|else|enum|extends|final|finally|float|for|goto|if|implements|import|in|instanceof|int|interface|long|native|new|package|private|protected|public|return|short|static|strictfp|super|switch|synchronized|this|throw|throws|trait|transient|try|void|volatile|while)\b/,
-      number: /\b(?:0b[01_]+|0x[\da-f_]+(?:\.[\da-f_p\-]+)?|[\d_]+(?:\.[\d_]+)?(?:e[+-]?\d+)?)[glidf]?\b/i,
-      operator: {
-        pattern: /(^|[^.])(?:~|==?~?|\?[.:]?|\*(?:[.=]|\*=?)?|\.[@&]|\.\.<|\.\.(?!\.)|-[-=>]?|\+[+=]?|!=?|<(?:<=?|=>?)?|>(?:>>?=?|=)?|&[&=]?|\|[|=]?|\/=?|\^=?|%=?)/,
-        lookbehind: !0
-      },
-      punctuation: /\.+|[{}[\];(),:$]/
-    }), e.languages.insertBefore("groovy", "string", {
-      shebang: {
-        pattern: /#!.+/,
-        alias: "comment"
-      }
-    }), e.languages.insertBefore("groovy", "punctuation", {
-      "spock-block": /\b(?:and|cleanup|expect|given|setup|then|when|where):/
-    }), e.languages.insertBefore("groovy", "function", {
-      annotation: {
-        pattern: /(^|[^.])@\w+/,
-        lookbehind: !0,
-        alias: "punctuation"
-      }
-    }), e.hooks.add("wrap", function(t) {
-      if (t.language === "groovy" && t.type === "string") {
-        var n = t.content.value[0];
-        if (n != "'") {
-          var r = /([^\\])(?:\$(?:\{.*?\}|[\w.]+))/;
-          n === "$" && (r = /([^\$])(?:\$(?:\{.*?\}|[\w.]+))/), t.content.value = t.content.value.replace(/&lt;/g, "<").replace(/&amp;/g, "&"), t.content = e.highlight(t.content.value, {
-            expression: {
-              pattern: r,
-              lookbehind: !0,
-              inside: e.languages.groovy
-            }
-          }), t.classes.push(n === "/" ? "regex" : "gstring");
-        }
-      }
-    });
-  }
-  return o;
-}
-export {
-  s as __require
-};

package/dist/es/node_modules/refractor/lang/haml.mjs

@@ -1,132 +0,0 @@
-import { __require as d } from "./ruby.mjs";
-var a, o;
-function c() {
-  if (o)
-    return a;
-  o = 1;
-  var s = d();
-  a = r, r.displayName = "haml", r.aliases = [];
-  function r(i) {
-    i.register(s), function(e) {
-      e.languages.haml = {
-        // Multiline stuff should appear before the rest
-        "multiline-comment": {
-          pattern: /((?:^|\r?\n|\r)([\t ]*))(?:\/|-#).*(?:(?:\r?\n|\r)\2[\t ].+)*/,
-          lookbehind: !0,
-          alias: "comment"
-        },
-        "multiline-code": [{
-          pattern: /((?:^|\r?\n|\r)([\t ]*)(?:[~-]|[&!]?=)).*,[\t ]*(?:(?:\r?\n|\r)\2[\t ].*,[\t ]*)*(?:(?:\r?\n|\r)\2[\t ].+)/,
-          lookbehind: !0,
-          inside: e.languages.ruby
-        }, {
-          pattern: /((?:^|\r?\n|\r)([\t ]*)(?:[~-]|[&!]?=)).*\|[\t ]*(?:(?:\r?\n|\r)\2[\t ].*\|[\t ]*)*/,
-          lookbehind: !0,
-          inside: e.languages.ruby
-        }],
-        // See at the end of the file for known filters
-        filter: {
-          pattern: /((?:^|\r?\n|\r)([\t ]*)):[\w-]+(?:(?:\r?\n|\r)(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/,
-          lookbehind: !0,
-          inside: {
-            "filter-name": {
-              pattern: /^:[\w-]+/,
-              alias: "symbol"
-            }
-          }
-        },
-        markup: {
-          pattern: /((?:^|\r?\n|\r)[\t ]*)<.+/,
-          lookbehind: !0,
-          inside: e.languages.markup
-        },
-        doctype: {
-          pattern: /((?:^|\r?\n|\r)[\t ]*)!!!(?: .+)?/,
-          lookbehind: !0
-        },
-        tag: {
-          // Allows for one nested group of braces
-          pattern: /((?:^|\r?\n|\r)[\t ]*)[%.#][\w\-#.]*[\w\-](?:\([^)]+\)|\{(?:\{[^}]+\}|[^{}])+\}|\[[^\]]+\])*[\/<>]*/,
-          lookbehind: !0,
-          inside: {
-            attributes: [{
-              // Lookbehind tries to prevent interpolations from breaking it all
-              // Allows for one nested group of braces
-              pattern: /(^|[^#])\{(?:\{[^}]+\}|[^{}])+\}/,
-              lookbehind: !0,
-              inside: e.languages.ruby
-            }, {
-              pattern: /\([^)]+\)/,
-              inside: {
-                "attr-value": {
-                  pattern: /(=\s*)(?:"(?:\\.|[^\\"\r\n])*"|[^)\s]+)/,
-                  lookbehind: !0
-                },
-                "attr-name": /[\w:-]+(?=\s*!?=|\s*[,)])/,
-                punctuation: /[=(),]/
-              }
-            }, {
-              pattern: /\[[^\]]+\]/,
-              inside: e.languages.ruby
-            }],
-            punctuation: /[<>]/
-          }
-        },
-        code: {
-          pattern: /((?:^|\r?\n|\r)[\t ]*(?:[~-]|[&!]?=)).+/,
-          lookbehind: !0,
-          inside: e.languages.ruby
-        },
-        // Interpolations in plain text
-        interpolation: {
-          pattern: /#\{[^}]+\}/,
-          inside: {
-            delimiter: {
-              pattern: /^#\{|\}$/,
-              alias: "punctuation"
-            },
-            ruby: {
-              pattern: /[\s\S]+/,
-              inside: e.languages.ruby
-            }
-          }
-        },
-        punctuation: {
-          pattern: /((?:^|\r?\n|\r)[\t ]*)[~=\-&!]+/,
-          lookbehind: !0
-        }
-      };
-      for (var g = "((?:^|\\r?\\n|\\r)([\\t ]*)):{{filter_name}}(?:(?:\\r?\\n|\\r)(?:\\2[\\t ].+|\\s*?(?=\\r?\\n|\\r)))+", u = ["css", {
-        filter: "coffee",
-        language: "coffeescript"
-      }, "erb", "javascript", "less", "markdown", "ruby", "scss", "textile"], l = {}, n = 0, p = u.length; n < p; n++) {
-        var t = u[n];
-        t = typeof t == "string" ? {
-          filter: t,
-          language: t
-        } : t, e.languages[t.language] && (l["filter-" + t.filter] = {
-          pattern: RegExp(g.replace("{{filter_name}}", function() {
-            return t.filter;
-          })),
-          lookbehind: !0,
-          inside: {
-            "filter-name": {
-              pattern: /^:[\w-]+/,
-              alias: "symbol"
-            },
-            text: {
-              pattern: /[\s\S]+/,
-              alias: [t.language, "language-" + t.language],
-              inside: e.languages[t.language]
-            }
-          }
-        });
-      }
-      e.languages.insertBefore("haml", "filter", l);
-    }(i);
-  }
-  return a;
-}
-export {
-  c as __require
-};

package/dist/es/node_modules/refractor/lang/handlebars.mjs

@@ -1,46 +0,0 @@
-import { __require as i } from "./markup-templating.mjs";
-var r, s;
-function d() {
-  if (s)
-    return r;
-  s = 1;
-  var l = i();
-  r = e, e.displayName = "handlebars", e.aliases = ["hbs"];
-  function e(t) {
-    t.register(l), function(a) {
-      a.languages.handlebars = {
-        comment: /\{\{![\s\S]*?\}\}/,
-        delimiter: {
-          pattern: /^\{\{\{?|\}\}\}?$/,
-          alias: "punctuation"
-        },
-        string: /(["'])(?:\\.|(?!\1)[^\\\r\n])*\1/,
-        number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][+-]?\d+)?/,
-        boolean: /\b(?:false|true)\b/,
-        block: {
-          pattern: /^(\s*(?:~\s*)?)[#\/]\S+?(?=\s*(?:~\s*)?$|\s)/,
-          lookbehind: !0,
-          alias: "keyword"
-        },
-        brackets: {
-          pattern: /\[[^\]]+\]/,
-          inside: {
-            punctuation: /\[|\]/,
-            variable: /[\s\S]+/
-          }
-        },
-        punctuation: /[!"#%&':()*+,.\/;<=>@\[\\\]^`{|}~]/,
-        variable: /[^!"#%&'()*+,\/;<=>@\[\\\]^`{|}~\s]+/
-      }, a.hooks.add("before-tokenize", function(n) {
-        var u = /\{\{\{[\s\S]+?\}\}\}|\{\{[\s\S]+?\}\}/g;
-        a.languages["markup-templating"].buildPlaceholders(n, "handlebars", u);
-      }), a.hooks.add("after-tokenize", function(n) {
-        a.languages["markup-templating"].tokenizePlaceholders(n, "handlebars");
-      }), a.languages.hbs = a.languages.handlebars;
-    }(t);
-  }
-  return r;
-}
-export {
-  d as __require
-};

package/dist/es/node_modules/refractor/lang/haskell.mjs

@@ -1,76 +0,0 @@
-var t, i;
-function r() {
-  if (i)
-    return t;
-  i = 1, t = e, e.displayName = "haskell", e.aliases = ["hs"];
-  function e(a) {
-    a.languages.haskell = {
-      comment: {
-        pattern: /(^|[^-!#$%*+=?&@|~.:<>^\\\/])(?:--(?:(?=.)[^-!#$%*+=?&@|~.:<>^\\\/].*|$)|\{-[\s\S]*?-\})/m,
-        lookbehind: !0
-      },
-      char: {
-        pattern: /'(?:[^\\']|\\(?:[abfnrtv\\"'&]|\^[A-Z@[\]^_]|ACK|BEL|BS|CAN|CR|DC1|DC2|DC3|DC4|DEL|DLE|EM|ENQ|EOT|ESC|ETB|ETX|FF|FS|GS|HT|LF|NAK|NUL|RS|SI|SO|SOH|SP|STX|SUB|SYN|US|VT|\d+|o[0-7]+|x[0-9a-fA-F]+))'/,
-        alias: "string"
-      },
-      string: {
-        pattern: /"(?:[^\\"]|\\(?:\S|\s+\\))*"/,
-        greedy: !0
-      },
-      keyword: /\b(?:case|class|data|deriving|do|else|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where)\b/,
-      "import-statement": {
-        // The imported or hidden names are not included in this import
-        // statement. This is because we want to highlight those exactly like
-        // we do for the names in the program.
-        pattern: /(^[\t ]*)import\s+(?:qualified\s+)?(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*(?:\s+as\s+(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*)?(?:\s+hiding\b)?/m,
-        lookbehind: !0,
-        inside: {
-          keyword: /\b(?:as|hiding|import|qualified)\b/,
-          punctuation: /\./
-        }
-      },
-      // These are builtin variables only. Constructors are highlighted later as a constant.
-      builtin: /\b(?:abs|acos|acosh|all|and|any|appendFile|approxRational|asTypeOf|asin|asinh|atan|atan2|atanh|basicIORun|break|catch|ceiling|chr|compare|concat|concatMap|const|cos|cosh|curry|cycle|decodeFloat|denominator|digitToInt|div|divMod|drop|dropWhile|either|elem|encodeFloat|enumFrom|enumFromThen|enumFromThenTo|enumFromTo|error|even|exp|exponent|fail|filter|flip|floatDigits|floatRadix|floatRange|floor|fmap|foldl|foldl1|foldr|foldr1|fromDouble|fromEnum|fromInt|fromInteger|fromIntegral|fromRational|fst|gcd|getChar|getContents|getLine|group|head|id|inRange|index|init|intToDigit|interact|ioError|isAlpha|isAlphaNum|isAscii|isControl|isDenormalized|isDigit|isHexDigit|isIEEE|isInfinite|isLower|isNaN|isNegativeZero|isOctDigit|isPrint|isSpace|isUpper|iterate|last|lcm|length|lex|lexDigits|lexLitChar|lines|log|logBase|lookup|map|mapM|mapM_|max|maxBound|maximum|maybe|min|minBound|minimum|mod|negate|not|notElem|null|numerator|odd|or|ord|otherwise|pack|pi|pred|primExitWith|print|product|properFraction|putChar|putStr|putStrLn|quot|quotRem|range|rangeSize|read|readDec|readFile|readFloat|readHex|readIO|readInt|readList|readLitChar|readLn|readOct|readParen|readSigned|reads|readsPrec|realToFrac|recip|rem|repeat|replicate|return|reverse|round|scaleFloat|scanl|scanl1|scanr|scanr1|seq|sequence|sequence_|show|showChar|showInt|showList|showLitChar|showParen|showSigned|showString|shows|showsPrec|significand|signum|sin|sinh|snd|sort|span|splitAt|sqrt|subtract|succ|sum|tail|take|takeWhile|tan|tanh|threadToIOResult|toEnum|toInt|toInteger|toLower|toRational|toUpper|truncate|uncurry|undefined|unlines|until|unwords|unzip|unzip3|userError|words|writeFile|zip|zip3|zipWith|zipWith3)\b/,
-      // decimal integers and floating point numbers | octal integers | hexadecimal integers
-      number: /\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0o[0-7]+|0x[0-9a-f]+)\b/i,
-      operator: [
-        {
-          // infix operator
-          pattern: /`(?:[A-Z][\w']*\.)*[_a-z][\w']*`/,
-          greedy: !0
-        },
-        {
-          // function composition
-          pattern: /(\s)\.(?=\s)/,
-          lookbehind: !0
-        },
-        // Most of this is needed because of the meaning of a single '.'.
-        // If it stands alone freely, it is the function composition.
-        // It may also be a separator between a module name and an identifier => no
-        // operator. If it comes together with other special characters it is an
-        // operator too.
-        //
-        // This regex means: /[-!#$%*+=?&@|~.:<>^\\\/]+/ without /\./.
-        /[-!#$%*+=?&@|~:<>^\\\/][-!#$%*+=?&@|~.:<>^\\\/]*|\.[-!#$%*+=?&@|~.:<>^\\\/]+/
-      ],
-      // In Haskell, nearly everything is a variable, do not highlight these.
-      hvariable: {
-        pattern: /\b(?:[A-Z][\w']*\.)*[_a-z][\w']*/,
-        inside: {
-          punctuation: /\./
-        }
-      },
-      constant: {
-        pattern: /\b(?:[A-Z][\w']*\.)*[A-Z][\w']*/,
-        inside: {
-          punctuation: /\./
-        }
-      },
-      punctuation: /[{}[\];(),.:]/
-    }, a.languages.hs = a.languages.haskell;
-  }
-  return t;
-}
-export {
-  r as __require
-};