@oscloudlab/knowledge-card 0.0.5 → 0.0.7

package/dist/nsis-CnjJR2FJ.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"nsis-CnjJR2FJ.js","sources":["../node_modules/refractor/lang/nsis.js"],"sourcesContent":["'use strict'\n\nmodule.exports = nsis\nnsis.displayName = 'nsis'\nnsis.aliases = []\nfunction nsis(Prism) {\n  /**\n   * Original by Jan T. Sott (http://github.com/idleberg)\n   *\n   * Includes all commands and plug-ins shipped with NSIS 3.08\n   */\n  Prism.languages.nsis = {\n    comment: {\n      pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?\\*\\/|[#;].*)/,\n      lookbehind: true,\n      greedy: true\n    },\n    string: {\n      pattern: /(\"|')(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/,\n      greedy: true\n    },\n    keyword: {\n      pattern:\n        /(^[\\t ]*)(?:Abort|Add(?:BrandingImage|Size)|AdvSplash|Allow(?:RootDirInstall|SkipFiles)|AutoCloseWindow|BG(?:Font|Gradient|Image)|Banner|BrandingText|BringToFront|CRCCheck|Call(?:InstDLL)?|Caption|ChangeUI|CheckBitmap|ClearErrors|CompletedText|ComponentText|CopyFiles|Create(?:Directory|Font|ShortCut)|Delete(?:INISec|INIStr|RegKey|RegValue)?|Detail(?:Print|sButtonText)|Dialer|Dir(?:Text|Var|Verify)|EnableWindow|Enum(?:RegKey|RegValue)|Exch|Exec(?:Shell(?:Wait)?|Wait)?|ExpandEnvStrings|File(?:BufSize|Close|ErrorText|Open|Read|ReadByte|ReadUTF16LE|ReadWord|Seek|Write|WriteByte|WriteUTF16LE|WriteWord)?|Find(?:Close|First|Next|Window)|FlushINI|Get(?:CurInstType|CurrentAddress|DLLVersion(?:Local)?|DlgItem|ErrorLevel|FileTime(?:Local)?|FullPathName|Function(?:Address|End)?|InstDirError|LabelAddress|TempFileName)|Goto|HideWindow|Icon|If(?:Abort|Errors|FileExists|RebootFlag|Silent)|InitPluginsDir|InstProgressFlags|Inst(?:Type(?:GetText|SetText)?)|Install(?:ButtonText|Colors|Dir(?:RegKey)?)|Int(?:64|Ptr)?CmpU?|Int(?:64)?Fmt|Int(?:Ptr)?Op|IsWindow|Lang(?:DLL|String)|License(?:BkColor|Data|ForceSelection|LangString|Text)|LoadLanguageFile|LockWindow|Log(?:Set|Text)|Manifest(?:DPIAware|SupportedOS)|Math|MessageBox|MiscButtonText|NSISdl|Name|Nop|OutFile|PE(?:DllCharacteristics|SubsysVer)|Page(?:Callbacks)?|Pop|Push|Quit|RMDir|Read(?:EnvStr|INIStr|RegDWORD|RegStr)|Reboot|RegDLL|Rename|RequestExecutionLevel|ReserveFile|Return|SearchPath|Section(?:End|GetFlags|GetInstTypes|GetSize|GetText|Group|In|SetFlags|SetInstTypes|SetSize|SetText)?|SendMessage|Set(?:AutoClose|BrandingImage|Compress|Compressor(?:DictSize)?|CtlColors|CurInstType|DatablockOptimize|DateSave|Details(?:Print|View)|ErrorLevel|Errors|FileAttributes|Font|OutPath|Overwrite|PluginUnload|RebootFlag|RegView|ShellVarContext|Silent)|Show(?:InstDetails|UninstDetails|Window)|Silent(?:Install|UnInstall)|Sleep|SpaceTexts|Splash|StartMenu|Str(?:CmpS?|Cpy|Len)|SubCaption|System|UnRegDLL|Unicode|UninstPage|Uninstall(?:ButtonText|Caption|Icon|SubCaption|Text)|UserInfo|VI(?:AddVersionKey|FileVersion|ProductVersion)|VPatch|Var|WindowIcon|Write(?:INIStr|Reg(?:Bin|DWORD|ExpandStr|MultiStr|None|Str)|Uninstaller)|XPStyle|ns(?:Dialogs|Exec))\\b/m,\n      lookbehind: true\n    },\n    property:\n      /\\b(?:ARCHIVE|FILE_(?:ATTRIBUTE_ARCHIVE|ATTRIBUTE_NORMAL|ATTRIBUTE_OFFLINE|ATTRIBUTE_READONLY|ATTRIBUTE_SYSTEM|ATTRIBUTE_TEMPORARY)|HK(?:(?:CR|CU|LM)(?:32|64)?|DD|PD|U)|HKEY_(?:CLASSES_ROOT|CURRENT_CONFIG|CURRENT_USER|DYN_DATA|LOCAL_MACHINE|PERFORMANCE_DATA|USERS)|ID(?:ABORT|CANCEL|IGNORE|NO|OK|RETRY|YES)|MB_(?:ABORTRETRYIGNORE|DEFBUTTON1|DEFBUTTON2|DEFBUTTON3|DEFBUTTON4|ICONEXCLAMATION|ICONINFORMATION|ICONQUESTION|ICONSTOP|OK|OKCANCEL|RETRYCANCEL|RIGHT|RTLREADING|SETFOREGROUND|TOPMOST|USERICON|YESNO)|NORMAL|OFFLINE|READONLY|SHCTX|SHELL_CONTEXT|SYSTEM|TEMPORARY|admin|all|auto|both|colored|false|force|hide|highest|lastused|leave|listonly|none|normal|notset|off|on|open|print|show|silent|silentlog|smooth|textonly|true|user)\\b/,\n    constant: /\\$\\{[!\\w\\.:\\^-]+\\}|\\$\\([!\\w\\.:\\^-]+\\)/,\n    variable: /\\$\\w[\\w\\.]*/,\n    number: /\\b0x[\\dA-Fa-f]+\\b|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:[Ee]-?\\d+)?/,\n    operator: /--?|\\+\\+?|<=?|>=?|==?=?|&&?|\\|\\|?|[?*\\/~^%]/,\n    punctuation: /[{}[\\];(),.:]/,\n    important: {\n      pattern:\n        /(^[\\t ]*)!(?:addincludedir|addplugindir|appendfile|cd|define|delfile|echo|else|endif|error|execute|finalize|getdllversion|gettlbversion|if|ifdef|ifmacrodef|ifmacrondef|ifndef|include|insertmacro|macro|macroend|makensis|packhdr|pragma|searchparse|searchreplace|system|tempfile|undef|verbose|warning)\\b/im,\n      lookbehind: true\n    }\n  }\n}\n"],"names":["nsis"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AAMnB,UAAM,UAAU,OAAO;AAAA,MACrB,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ;AAAA;MAEV,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,SAAS;AAAA,QACP,SACE;AAAA,QACF,YAAY;AAAA;MAEd,UACE;AAAA,MACF,UAAU;AAAA,MACV,UAAU;AAAA,MACV,QAAQ;AAAA,MACR,UAAU;AAAA,MACV,aAAa;AAAA,MACb,WAAW;AAAA,QACT,SACE;AAAA,QACF,YAAY;AAAA;;EAGlB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/objectivec-CTui2_eD.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"objectivec-CTui2_eD.js","sources":["../node_modules/refractor/lang/objectivec.js"],"sourcesContent":["'use strict'\nvar refractorC = require('./c.js')\nmodule.exports = objectivec\nobjectivec.displayName = 'objectivec'\nobjectivec.aliases = ['objc']\nfunction objectivec(Prism) {\n  Prism.register(refractorC)\n  Prism.languages.objectivec = Prism.languages.extend('c', {\n    string: {\n      pattern: /@?\"(?:\\\\(?:\\r\\n|[\\s\\S])|[^\"\\\\\\r\\n])*\"/,\n      greedy: true\n    },\n    keyword:\n      /\\b(?:asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|in|inline|int|long|register|return|self|short|signed|sizeof|static|struct|super|switch|typedef|typeof|union|unsigned|void|volatile|while)\\b|(?:@interface|@end|@implementation|@protocol|@class|@public|@protected|@private|@property|@try|@catch|@finally|@throw|@synthesize|@dynamic|@selector)\\b/,\n    operator: /-[->]?|\\+\\+?|!=?|<<?=?|>>?=?|==?|&&?|\\|\\|?|[~^%?*\\/@]/\n  })\n  delete Prism.languages.objectivec['class-name']\n  Prism.languages.objc = Prism.languages.objectivec\n}\n"],"names":["require$$0","objectivec"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,aAAaA,SAAA;AACjB,iBAAiBC;AACjB,EAAAA,YAAW,cAAc;AACzB,EAAAA,YAAW,UAAU,CAAC,MAAM;AAC5B,WAASA,YAAW,OAAO;AACzB,UAAM,SAAS,UAAU;AACzB,UAAM,UAAU,aAAa,MAAM,UAAU,OAAO,KAAK;AAAA,MACvD,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,SACE;AAAA,MACF,UAAU;AAAA,IACd,CAAG;AACD,WAAO,MAAM,UAAU,WAAW,YAAY;AAC9C,UAAM,UAAU,OAAO,MAAM,UAAU;AAAA,EACzC;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/ocaml-DFVfU8pu.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ocaml-DFVfU8pu.js","sources":["../node_modules/refractor/lang/ocaml.js"],"sourcesContent":["'use strict'\n\nmodule.exports = ocaml\nocaml.displayName = 'ocaml'\nocaml.aliases = []\nfunction ocaml(Prism) {\n  // https://ocaml.org/manual/lex.html\n  Prism.languages.ocaml = {\n    comment: {\n      pattern: /\\(\\*[\\s\\S]*?\\*\\)/,\n      greedy: true\n    },\n    char: {\n      pattern: /'(?:[^\\\\\\r\\n']|\\\\(?:.|[ox]?[0-9a-f]{1,3}))'/i,\n      greedy: true\n    },\n    string: [\n      {\n        pattern: /\"(?:\\\\(?:[\\s\\S]|\\r\\n)|[^\\\\\\r\\n\"])*\"/,\n        greedy: true\n      },\n      {\n        pattern: /\\{([a-z_]*)\\|[\\s\\S]*?\\|\\1\\}/,\n        greedy: true\n      }\n    ],\n    number: [\n      // binary and octal\n      /\\b(?:0b[01][01_]*|0o[0-7][0-7_]*)\\b/i, // hexadecimal\n      /\\b0x[a-f0-9][a-f0-9_]*(?:\\.[a-f0-9_]*)?(?:p[+-]?\\d[\\d_]*)?(?!\\w)/i, // decimal\n      /\\b\\d[\\d_]*(?:\\.[\\d_]*)?(?:e[+-]?\\d[\\d_]*)?(?!\\w)/i\n    ],\n    directive: {\n      pattern: /\\B#\\w+/,\n      alias: 'property'\n    },\n    label: {\n      pattern: /\\B~\\w+/,\n      alias: 'property'\n    },\n    'type-variable': {\n      pattern: /\\B'\\w+/,\n      alias: 'function'\n    },\n    variant: {\n      pattern: /`\\w+/,\n      alias: 'symbol'\n    },\n    // For the list of keywords and operators,\n    // see: http://caml.inria.fr/pub/docs/manual-ocaml/lex.html#sec84\n    keyword:\n      /\\b(?:as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|match|method|module|mutable|new|nonrec|object|of|open|private|rec|sig|struct|then|to|try|type|val|value|virtual|when|where|while|with)\\b/,\n    boolean: /\\b(?:false|true)\\b/,\n    'operator-like-punctuation': {\n      pattern: /\\[[<>|]|[>|]\\]|\\{<|>\\}/,\n      alias: 'punctuation'\n    },\n    // Custom operators are allowed\n    operator:\n      /\\.[.~]|:[=>]|[=<>@^|&+\\-*\\/$%!?~][!$%&*+\\-.\\/:<=>?@^|~]*|\\b(?:and|asr|land|lor|lsl|lsr|lxor|mod|or)\\b/,\n    punctuation: /;;|::|[(){}\\[\\].,:;#]|\\b_\\b/\n  }\n}\n"],"names":["ocaml"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,YAAiBA;AACjB,EAAAA,OAAM,cAAc;AACpB,EAAAA,OAAM,UAAU,CAAA;AAChB,WAASA,OAAM,OAAO;AAEpB,UAAM,UAAU,QAAQ;AAAA,MACtB,SAAS;AAAA,QACP,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,MAAM;AAAA,QACJ,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,QAAQ;AAAA,QACN;AAAA,UACE,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV;AAAA,UACE,SAAS;AAAA,UACT,QAAQ;AAAA;;MAGZ,QAAQ;AAAA;AAAA,QAEN;AAAA;AAAA,QACA;AAAA;AAAA,QACA;AAAA;MAEF,WAAW;AAAA,QACT,SAAS;AAAA,QACT,OAAO;AAAA;MAET,OAAO;AAAA,QACL,SAAS;AAAA,QACT,OAAO;AAAA;MAET,iBAAiB;AAAA,QACf,SAAS;AAAA,QACT,OAAO;AAAA;MAET,SAAS;AAAA,QACP,SAAS;AAAA,QACT,OAAO;AAAA;;;MAIT,SACE;AAAA,MACF,SAAS;AAAA,MACT,6BAA6B;AAAA,QAC3B,SAAS;AAAA,QACT,OAAO;AAAA;;MAGT,UACE;AAAA,MACF,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/opencl-DS4FQSRf.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"opencl-DS4FQSRf.js","sources":["../node_modules/refractor/lang/opencl.js"],"sourcesContent":["'use strict'\nvar refractorC = require('./c.js')\nmodule.exports = opencl\nopencl.displayName = 'opencl'\nopencl.aliases = []\nfunction opencl(Prism) {\n  Prism.register(refractorC)\n  ;(function (Prism) {\n    /* OpenCL kernel language */\n    Prism.languages.opencl = Prism.languages.extend('c', {\n      // Extracted from the official specs (2.0) and http://streamcomputing.eu/downloads/?opencl.lang (opencl-keywords, opencl-types) and http://sourceforge.net/tracker/?func=detail&aid=2957794&group_id=95717&atid=612384 (Words2, partly Words3)\n      keyword:\n        /\\b(?:(?:__)?(?:constant|global|kernel|local|private|read_only|read_write|write_only)|__attribute__|auto|(?:bool|u?(?:char|int|long|short)|half|quad)(?:2|3|4|8|16)?|break|case|complex|const|continue|(?:double|float)(?:16(?:x(?:1|2|4|8|16))?|1x(?:1|2|4|8|16)|2(?:x(?:1|2|4|8|16))?|3|4(?:x(?:1|2|4|8|16))?|8(?:x(?:1|2|4|8|16))?)?|default|do|else|enum|extern|for|goto|if|imaginary|inline|packed|pipe|register|restrict|return|signed|sizeof|static|struct|switch|typedef|uniform|union|unsigned|void|volatile|while)\\b/,\n      // Extracted from http://streamcomputing.eu/downloads/?opencl.lang (opencl-const)\n      // Math Constants: https://www.khronos.org/registry/OpenCL/sdk/2.1/docs/man/xhtml/mathConstants.html\n      // Macros and Limits: https://www.khronos.org/registry/OpenCL/sdk/2.1/docs/man/xhtml/macroLimits.html\n      number:\n        /(?:\\b0x(?:[\\da-f]+(?:\\.[\\da-f]*)?|\\.[\\da-f]+)(?:p[+-]?\\d+)?|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:e[+-]?\\d+)?)[fuhl]{0,4}/i,\n      boolean: /\\b(?:false|true)\\b/,\n      'constant-opencl-kernel': {\n        pattern:\n          /\\b(?:CHAR_(?:BIT|MAX|MIN)|CLK_(?:ADDRESS_(?:CLAMP(?:_TO_EDGE)?|NONE|REPEAT)|FILTER_(?:LINEAR|NEAREST)|(?:GLOBAL|LOCAL)_MEM_FENCE|NORMALIZED_COORDS_(?:FALSE|TRUE))|CL_(?:BGRA|(?:HALF_)?FLOAT|INTENSITY|LUMINANCE|A?R?G?B?[Ax]?|(?:(?:UN)?SIGNED|[US]NORM)_(?:INT(?:8|16|32))|UNORM_(?:INT_101010|SHORT_(?:555|565)))|(?:DBL|FLT|HALF)_(?:DIG|EPSILON|(?:MAX|MIN)(?:(?:_10)?_EXP)?|MANT_DIG)|FLT_RADIX|HUGE_VALF?|(?:INT|LONG|SCHAR|SHRT)_(?:MAX|MIN)|INFINITY|MAXFLOAT|M_(?:[12]_PI|2_SQRTPI|E|LN(?:2|10)|LOG(?:2|10)E?|PI(?:_[24])?|SQRT(?:1_2|2))(?:_F|_H)?|NAN|(?:UCHAR|UINT|ULONG|USHRT)_MAX)\\b/,\n        alias: 'constant'\n      }\n    })\n    Prism.languages.insertBefore('opencl', 'class-name', {\n      // https://www.khronos.org/registry/OpenCL/sdk/2.1/docs/man/xhtml/scalarDataTypes.html\n      // https://www.khronos.org/registry/OpenCL/sdk/2.1/docs/man/xhtml/otherDataTypes.html\n      'builtin-type': {\n        pattern:\n          /\\b(?:_cl_(?:command_queue|context|device_id|event|kernel|mem|platform_id|program|sampler)|cl_(?:image_format|mem_fence_flags)|clk_event_t|event_t|image(?:1d_(?:array_|buffer_)?t|2d_(?:array_(?:depth_|msaa_depth_|msaa_)?|depth_|msaa_depth_|msaa_)?t|3d_t)|intptr_t|ndrange_t|ptrdiff_t|queue_t|reserve_id_t|sampler_t|size_t|uintptr_t)\\b/,\n        alias: 'keyword'\n      }\n    })\n    var attributes = {\n      // Extracted from http://streamcomputing.eu/downloads/?opencl_host.lang (opencl-types and opencl-host)\n      'type-opencl-host': {\n        pattern:\n          /\\b(?:cl_(?:GLenum|GLint|GLuin|addressing_mode|bitfield|bool|buffer_create_type|build_status|channel_(?:order|type)|(?:u?(?:char|int|long|short)|double|float)(?:2|3|4|8|16)?|command_(?:queue(?:_info|_properties)?|type)|context(?:_info|_properties)?|device_(?:exec_capabilities|fp_config|id|info|local_mem_type|mem_cache_type|type)|(?:event|sampler)(?:_info)?|filter_mode|half|image_info|kernel(?:_info|_work_group_info)?|map_flags|mem(?:_flags|_info|_object_type)?|platform_(?:id|info)|profiling_info|program(?:_build_info|_info)?))\\b/,\n        alias: 'keyword'\n      },\n      'boolean-opencl-host': {\n        pattern: /\\bCL_(?:FALSE|TRUE)\\b/,\n        alias: 'boolean'\n      },\n      // Extracted from cl.h (2.0) and http://streamcomputing.eu/downloads/?opencl_host.lang (opencl-const)\n      'constant-opencl-host': {\n        pattern:\n          /\\bCL_(?:A|ABGR|ADDRESS_(?:CLAMP(?:_TO_EDGE)?|MIRRORED_REPEAT|NONE|REPEAT)|ARGB|BGRA|BLOCKING|BUFFER_CREATE_TYPE_REGION|BUILD_(?:ERROR|IN_PROGRESS|NONE|PROGRAM_FAILURE|SUCCESS)|COMMAND_(?:ACQUIRE_GL_OBJECTS|BARRIER|COPY_(?:BUFFER(?:_RECT|_TO_IMAGE)?|IMAGE(?:_TO_BUFFER)?)|FILL_(?:BUFFER|IMAGE)|MAP(?:_BUFFER|_IMAGE)|MARKER|MIGRATE(?:_SVM)?_MEM_OBJECTS|NATIVE_KERNEL|NDRANGE_KERNEL|READ_(?:BUFFER(?:_RECT)?|IMAGE)|RELEASE_GL_OBJECTS|SVM_(?:FREE|MAP|MEMCPY|MEMFILL|UNMAP)|TASK|UNMAP_MEM_OBJECT|USER|WRITE_(?:BUFFER(?:_RECT)?|IMAGE))|COMPILER_NOT_AVAILABLE|COMPILE_PROGRAM_FAILURE|COMPLETE|CONTEXT_(?:DEVICES|INTEROP_USER_SYNC|NUM_DEVICES|PLATFORM|PROPERTIES|REFERENCE_COUNT)|DEPTH(?:_STENCIL)?|DEVICE_(?:ADDRESS_BITS|AFFINITY_DOMAIN_(?:L[1-4]_CACHE|NEXT_PARTITIONABLE|NUMA)|AVAILABLE|BUILT_IN_KERNELS|COMPILER_AVAILABLE|DOUBLE_FP_CONFIG|ENDIAN_LITTLE|ERROR_CORRECTION_SUPPORT|EXECUTION_CAPABILITIES|EXTENSIONS|GLOBAL_(?:MEM_(?:CACHELINE_SIZE|CACHE_SIZE|CACHE_TYPE|SIZE)|VARIABLE_PREFERRED_TOTAL_SIZE)|HOST_UNIFIED_MEMORY|IL_VERSION|IMAGE(?:2D_MAX_(?:HEIGHT|WIDTH)|3D_MAX_(?:DEPTH|HEIGHT|WIDTH)|_BASE_ADDRESS_ALIGNMENT|_MAX_ARRAY_SIZE|_MAX_BUFFER_SIZE|_PITCH_ALIGNMENT|_SUPPORT)|LINKER_AVAILABLE|LOCAL_MEM_SIZE|LOCAL_MEM_TYPE|MAX_(?:CLOCK_FREQUENCY|COMPUTE_UNITS|CONSTANT_ARGS|CONSTANT_BUFFER_SIZE|GLOBAL_VARIABLE_SIZE|MEM_ALLOC_SIZE|NUM_SUB_GROUPS|ON_DEVICE_(?:EVENTS|QUEUES)|PARAMETER_SIZE|PIPE_ARGS|READ_IMAGE_ARGS|READ_WRITE_IMAGE_ARGS|SAMPLERS|WORK_GROUP_SIZE|WORK_ITEM_DIMENSIONS|WORK_ITEM_SIZES|WRITE_IMAGE_ARGS)|MEM_BASE_ADDR_ALIGN|MIN_DATA_TYPE_ALIGN_SIZE|NAME|NATIVE_VECTOR_WIDTH_(?:CHAR|DOUBLE|FLOAT|HALF|INT|LONG|SHORT)|NOT_(?:AVAILABLE|FOUND)|OPENCL_C_VERSION|PARENT_DEVICE|PARTITION_(?:AFFINITY_DOMAIN|BY_AFFINITY_DOMAIN|BY_COUNTS|BY_COUNTS_LIST_END|EQUALLY|FAILED|MAX_SUB_DEVICES|PROPERTIES|TYPE)|PIPE_MAX_(?:ACTIVE_RESERVATIONS|PACKET_SIZE)|PLATFORM|PREFERRED_(?:GLOBAL_ATOMIC_ALIGNMENT|INTEROP_USER_SYNC|LOCAL_ATOMIC_ALIGNMENT|PLATFORM_ATOMIC_ALIGNMENT|VECTOR_WIDTH_(?:CHAR|DOUBLE|FLOAT|HALF|INT|LONG|SHORT))|PRINTF_BUFFER_SIZE|PROFILE|PROFILING_TIMER_RESOLUTION|QUEUE_(?:ON_(?:DEVICE_(?:MAX_SIZE|PREFERRED_SIZE|PROPERTIES)|HOST_PROPERTIES)|PROPERTIES)|REFERENCE_COUNT|SINGLE_FP_CONFIG|SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS|SVM_(?:ATOMICS|CAPABILITIES|COARSE_GRAIN_BUFFER|FINE_GRAIN_BUFFER|FINE_GRAIN_SYSTEM)|TYPE(?:_ACCELERATOR|_ALL|_CPU|_CUSTOM|_DEFAULT|_GPU)?|VENDOR(?:_ID)?|VERSION)|DRIVER_VERSION|EVENT_(?:COMMAND_(?:EXECUTION_STATUS|QUEUE|TYPE)|CONTEXT|REFERENCE_COUNT)|EXEC_(?:KERNEL|NATIVE_KERNEL|STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST)|FILTER_(?:LINEAR|NEAREST)|FLOAT|FP_(?:CORRECTLY_ROUNDED_DIVIDE_SQRT|DENORM|FMA|INF_NAN|ROUND_TO_INF|ROUND_TO_NEAREST|ROUND_TO_ZERO|SOFT_FLOAT)|GLOBAL|HALF_FLOAT|IMAGE_(?:ARRAY_SIZE|BUFFER|DEPTH|ELEMENT_SIZE|FORMAT|FORMAT_MISMATCH|FORMAT_NOT_SUPPORTED|HEIGHT|NUM_MIP_LEVELS|NUM_SAMPLES|ROW_PITCH|SLICE_PITCH|WIDTH)|INTENSITY|INVALID_(?:ARG_INDEX|ARG_SIZE|ARG_VALUE|BINARY|BUFFER_SIZE|BUILD_OPTIONS|COMMAND_QUEUE|COMPILER_OPTIONS|CONTEXT|DEVICE|DEVICE_PARTITION_COUNT|DEVICE_QUEUE|DEVICE_TYPE|EVENT|EVENT_WAIT_LIST|GLOBAL_OFFSET|GLOBAL_WORK_SIZE|GL_OBJECT|HOST_PTR|IMAGE_DESCRIPTOR|IMAGE_FORMAT_DESCRIPTOR|IMAGE_SIZE|KERNEL|KERNEL_ARGS|KERNEL_DEFINITION|KERNEL_NAME|LINKER_OPTIONS|MEM_OBJECT|MIP_LEVEL|OPERATION|PIPE_SIZE|PLATFORM|PROGRAM|PROGRAM_EXECUTABLE|PROPERTY|QUEUE_PROPERTIES|SAMPLER|VALUE|WORK_DIMENSION|WORK_GROUP_SIZE|WORK_ITEM_SIZE)|KERNEL_(?:ARG_(?:ACCESS_(?:NONE|QUALIFIER|READ_ONLY|READ_WRITE|WRITE_ONLY)|ADDRESS_(?:CONSTANT|GLOBAL|LOCAL|PRIVATE|QUALIFIER)|INFO_NOT_AVAILABLE|NAME|TYPE_(?:CONST|NAME|NONE|PIPE|QUALIFIER|RESTRICT|VOLATILE))|ATTRIBUTES|COMPILE_NUM_SUB_GROUPS|COMPILE_WORK_GROUP_SIZE|CONTEXT|EXEC_INFO_SVM_FINE_GRAIN_SYSTEM|EXEC_INFO_SVM_PTRS|FUNCTION_NAME|GLOBAL_WORK_SIZE|LOCAL_MEM_SIZE|LOCAL_SIZE_FOR_SUB_GROUP_COUNT|MAX_NUM_SUB_GROUPS|MAX_SUB_GROUP_SIZE_FOR_NDRANGE|NUM_ARGS|PREFERRED_WORK_GROUP_SIZE_MULTIPLE|PRIVATE_MEM_SIZE|PROGRAM|REFERENCE_COUNT|SUB_GROUP_COUNT_FOR_NDRANGE|WORK_GROUP_SIZE)|LINKER_NOT_AVAILABLE|LINK_PROGRAM_FAILURE|LOCAL|LUMINANCE|MAP_(?:FAILURE|READ|WRITE|WRITE_INVALIDATE_REGION)|MEM_(?:ALLOC_HOST_PTR|ASSOCIATED_MEMOBJECT|CONTEXT|COPY_HOST_PTR|COPY_OVERLAP|FLAGS|HOST_NO_ACCESS|HOST_PTR|HOST_READ_ONLY|HOST_WRITE_ONLY|KERNEL_READ_AND_WRITE|MAP_COUNT|OBJECT_(?:ALLOCATION_FAILURE|BUFFER|IMAGE1D|IMAGE1D_ARRAY|IMAGE1D_BUFFER|IMAGE2D|IMAGE2D_ARRAY|IMAGE3D|PIPE)|OFFSET|READ_ONLY|READ_WRITE|REFERENCE_COUNT|SIZE|SVM_ATOMICS|SVM_FINE_GRAIN_BUFFER|TYPE|USES_SVM_POINTER|USE_HOST_PTR|WRITE_ONLY)|MIGRATE_MEM_OBJECT_(?:CONTENT_UNDEFINED|HOST)|MISALIGNED_SUB_BUFFER_OFFSET|NONE|NON_BLOCKING|OUT_OF_(?:HOST_MEMORY|RESOURCES)|PIPE_(?:MAX_PACKETS|PACKET_SIZE)|PLATFORM_(?:EXTENSIONS|HOST_TIMER_RESOLUTION|NAME|PROFILE|VENDOR|VERSION)|PROFILING_(?:COMMAND_(?:COMPLETE|END|QUEUED|START|SUBMIT)|INFO_NOT_AVAILABLE)|PROGRAM_(?:BINARIES|BINARY_SIZES|BINARY_TYPE(?:_COMPILED_OBJECT|_EXECUTABLE|_LIBRARY|_NONE)?|BUILD_(?:GLOBAL_VARIABLE_TOTAL_SIZE|LOG|OPTIONS|STATUS)|CONTEXT|DEVICES|IL|KERNEL_NAMES|NUM_DEVICES|NUM_KERNELS|REFERENCE_COUNT|SOURCE)|QUEUED|QUEUE_(?:CONTEXT|DEVICE|DEVICE_DEFAULT|ON_DEVICE|ON_DEVICE_DEFAULT|OUT_OF_ORDER_EXEC_MODE_ENABLE|PROFILING_ENABLE|PROPERTIES|REFERENCE_COUNT|SIZE)|R|RA|READ_(?:ONLY|WRITE)_CACHE|RG|RGB|RGBA|RGBx|RGx|RUNNING|Rx|SAMPLER_(?:ADDRESSING_MODE|CONTEXT|FILTER_MODE|LOD_MAX|LOD_MIN|MIP_FILTER_MODE|NORMALIZED_COORDS|REFERENCE_COUNT)|(?:UN)?SIGNED_INT(?:8|16|32)|SNORM_INT(?:8|16)|SUBMITTED|SUCCESS|UNORM_INT(?:8|16|24|_101010|_101010_2)|UNORM_SHORT_(?:555|565)|VERSION_(?:1_0|1_1|1_2|2_0|2_1)|sBGRA|sRGB|sRGBA|sRGBx)\\b/,\n        alias: 'constant'\n      },\n      // Extracted from cl.h (2.0) and http://streamcomputing.eu/downloads/?opencl_host.lang (opencl-host)\n      'function-opencl-host': {\n        pattern:\n          /\\bcl(?:BuildProgram|CloneKernel|CompileProgram|Create(?:Buffer|CommandQueue(?:WithProperties)?|Context|ContextFromType|Image|Image2D|Image3D|Kernel|KernelsInProgram|Pipe|ProgramWith(?:Binary|BuiltInKernels|IL|Source)|Sampler|SamplerWithProperties|SubBuffer|SubDevices|UserEvent)|Enqueue(?:(?:Barrier|Marker)(?:WithWaitList)?|Copy(?:Buffer(?:Rect|ToImage)?|Image(?:ToBuffer)?)|(?:Fill|Map)(?:Buffer|Image)|MigrateMemObjects|NDRangeKernel|NativeKernel|(?:Read|Write)(?:Buffer(?:Rect)?|Image)|SVM(?:Free|Map|MemFill|Memcpy|MigrateMem|Unmap)|Task|UnmapMemObject|WaitForEvents)|Finish|Flush|Get(?:CommandQueueInfo|ContextInfo|Device(?:AndHostTimer|IDs|Info)|Event(?:Profiling)?Info|ExtensionFunctionAddress(?:ForPlatform)?|HostTimer|ImageInfo|Kernel(?:ArgInfo|Info|SubGroupInfo|WorkGroupInfo)|MemObjectInfo|PipeInfo|Platform(?:IDs|Info)|Program(?:Build)?Info|SamplerInfo|SupportedImageFormats)|LinkProgram|(?:Release|Retain)(?:CommandQueue|Context|Device|Event|Kernel|MemObject|Program|Sampler)|SVM(?:Alloc|Free)|Set(?:CommandQueueProperty|DefaultDeviceCommandQueue|EventCallback|Kernel|Kernel(?:Arg(?:SVMPointer)?|ExecInfo)|MemObjectDestructorCallback|UserEventStatus)|Unload(?:Platform)?Compiler|WaitForEvents)\\b/,\n        alias: 'function'\n      }\n    }\n    /* OpenCL host API */\n    Prism.languages.insertBefore('c', 'keyword', attributes) // C++ includes everything from the OpenCL C host API plus the classes defined in cl2.h\n    if (Prism.languages.cpp) {\n      // Extracted from doxygen class list http://github.khronos.org/OpenCL-CLHPP/annotated.html\n      attributes['type-opencl-host-cpp'] = {\n        pattern:\n          /\\b(?:Buffer|BufferGL|BufferRenderGL|CommandQueue|Context|Device|DeviceCommandQueue|EnqueueArgs|Event|Image|Image1D|Image1DArray|Image1DBuffer|Image2D|Image2DArray|Image2DGL|Image3D|Image3DGL|ImageFormat|ImageGL|Kernel|KernelFunctor|LocalSpaceArg|Memory|NDRange|Pipe|Platform|Program|SVMAllocator|SVMTraitAtomic|SVMTraitCoarse|SVMTraitFine|SVMTraitReadOnly|SVMTraitReadWrite|SVMTraitWriteOnly|Sampler|UserEvent)\\b/,\n        alias: 'keyword'\n      }\n      Prism.languages.insertBefore('cpp', 'keyword', attributes)\n    }\n  })(Prism)\n}\n"],"names":["require$$0","opencl","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,aAAaA,SAAA;AACjB,aAAiBC;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAA;AACjB,WAASA,QAAO,OAAO;AACrB,UAAM,SAAS,UAAU;AACxB,KAAC,SAAUC,QAAO;AAEjB,MAAAA,OAAM,UAAU,SAASA,OAAM,UAAU,OAAO,KAAK;AAAA;AAAA,QAEnD,SACE;AAAA;AAAA;AAAA;AAAA,QAIF,QACE;AAAA,QACF,SAAS;AAAA,QACT,0BAA0B;AAAA,UACxB,SACE;AAAA,UACF,OAAO;AAAA;MAEf,CAAK;AACD,MAAAA,OAAM,UAAU,aAAa,UAAU,cAAc;AAAA;AAAA;AAAA,QAGnD,gBAAgB;AAAA,UACd,SACE;AAAA,UACF,OAAO;AAAA;MAEf,CAAK;AACD,UAAI,aAAa;AAAA;AAAA,QAEf,oBAAoB;AAAA,UAClB,SACE;AAAA,UACF,OAAO;AAAA;QAET,uBAAuB;AAAA,UACrB,SAAS;AAAA,UACT,OAAO;AAAA;;QAGT,wBAAwB;AAAA,UACtB,SACE;AAAA,UACF,OAAO;AAAA;;QAGT,wBAAwB;AAAA,UACtB,SACE;AAAA,UACF,OAAO;AAAA;;AAIX,MAAAA,OAAM,UAAU,aAAa,KAAK,WAAW,UAAU;AACvD,UAAIA,OAAM,UAAU,KAAK;AAEvB,mBAAW,sBAAsB,IAAI;AAAA,UACnC,SACE;AAAA,UACF,OAAO;AAAA;AAET,QAAAA,OAAM,UAAU,aAAa,OAAO,WAAW,UAAU;AAAA,MAC/D;AAAA,IACA,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/openqasm-N4v30NRT.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"openqasm-N4v30NRT.js","sources":["../node_modules/refractor/lang/openqasm.js"],"sourcesContent":["'use strict'\n\nmodule.exports = openqasm\nopenqasm.displayName = 'openqasm'\nopenqasm.aliases = ['qasm']\nfunction openqasm(Prism) {\n  // https://qiskit.github.io/openqasm/grammar/index.html\n  Prism.languages.openqasm = {\n    comment: /\\/\\*[\\s\\S]*?\\*\\/|\\/\\/.*/,\n    string: {\n      pattern: /\"[^\"\\r\\n\\t]*\"|'[^'\\r\\n\\t]*'/,\n      greedy: true\n    },\n    keyword:\n      /\\b(?:CX|OPENQASM|U|barrier|boxas|boxto|break|const|continue|ctrl|def|defcal|defcalgrammar|delay|else|end|for|gate|gphase|if|in|include|inv|kernel|lengthof|let|measure|pow|reset|return|rotary|stretchinf|while)\\b|#pragma\\b/,\n    'class-name':\n      /\\b(?:angle|bit|bool|creg|fixed|float|int|length|qreg|qubit|stretch|uint)\\b/,\n    function: /\\b(?:cos|exp|ln|popcount|rotl|rotr|sin|sqrt|tan)\\b(?=\\s*\\()/,\n    constant: /\\b(?:euler|pi|tau)\\b|π|𝜏|ℇ/,\n    number: {\n      pattern:\n        /(^|[^.\\w$])(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?(?:dt|ns|us|µs|ms|s)?/i,\n      lookbehind: true\n    },\n    operator: /->|>>=?|<<=?|&&|\\|\\||\\+\\+|--|[!=<>&|~^+\\-*/%]=?|@/,\n    punctuation: /[(){}\\[\\];,:.]/\n  }\n  Prism.languages.qasm = Prism.languages.openqasm\n}\n"],"names":["openqasm"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,eAAiBA;AACjB,EAAAA,UAAS,cAAc;AACvB,EAAAA,UAAS,UAAU,CAAC,MAAM;AAC1B,WAASA,UAAS,OAAO;AAEvB,UAAM,UAAU,WAAW;AAAA,MACzB,SAAS;AAAA,MACT,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,SACE;AAAA,MACF,cACE;AAAA,MACF,UAAU;AAAA,MACV,UAAU;AAAA,MACV,QAAQ;AAAA,QACN,SACE;AAAA,QACF,YAAY;AAAA;MAEd,UAAU;AAAA,MACV,aAAa;AAAA;AAEf,UAAM,UAAU,OAAO,MAAM,UAAU;AAAA,EACzC;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/oz-CcBwRBVN.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"oz-CcBwRBVN.js","sources":["../node_modules/refractor/lang/oz.js"],"sourcesContent":["'use strict'\n\nmodule.exports = oz\noz.displayName = 'oz'\noz.aliases = []\nfunction oz(Prism) {\n  Prism.languages.oz = {\n    comment: {\n      pattern: /\\/\\*[\\s\\S]*?\\*\\/|%.*/,\n      greedy: true\n    },\n    string: {\n      pattern: /\"(?:[^\"\\\\]|\\\\[\\s\\S])*\"/,\n      greedy: true\n    },\n    atom: {\n      pattern: /'(?:[^'\\\\]|\\\\[\\s\\S])*'/,\n      greedy: true,\n      alias: 'builtin'\n    },\n    keyword:\n      /\\$|\\[\\]|\\b(?:_|at|attr|case|catch|choice|class|cond|declare|define|dis|else(?:case|if)?|end|export|fail|false|feat|finally|from|fun|functor|if|import|in|local|lock|meth|nil|not|of|or|prepare|proc|prop|raise|require|self|skip|then|thread|true|try|unit)\\b/,\n    function: [\n      /\\b[a-z][A-Za-z\\d]*(?=\\()/,\n      {\n        pattern: /(\\{)[A-Z][A-Za-z\\d]*\\b/,\n        lookbehind: true\n      }\n    ],\n    number:\n      /\\b(?:0[bx][\\da-f]+|\\d+(?:\\.\\d*)?(?:e~?\\d+)?)\\b|&(?:[^\\\\]|\\\\(?:\\d{3}|.))/i,\n    variable: /`(?:[^`\\\\]|\\\\.)+`/,\n    'attr-name': /\\b\\w+(?=[ \\t]*:(?![:=]))/,\n    operator:\n      /:(?:=|::?)|<[-:=]?|=(?:=|<?:?)|>=?:?|\\\\=:?|!!?|[|#+\\-*\\/,~^@]|\\b(?:andthen|div|mod|orelse)\\b/,\n    punctuation: /[\\[\\](){}.:;?]/\n  }\n}\n"],"names":["oz"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,SAAiBA;AACjB,EAAAA,IAAG,cAAc;AACjB,EAAAA,IAAG,UAAU,CAAA;AACb,WAASA,IAAG,OAAO;AACjB,UAAM,UAAU,KAAK;AAAA,MACnB,SAAS;AAAA,QACP,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,MAAM;AAAA,QACJ,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,OAAO;AAAA;MAET,SACE;AAAA,MACF,UAAU;AAAA,QACR;AAAA,QACA;AAAA,UACE,SAAS;AAAA,UACT,YAAY;AAAA;;MAGhB,QACE;AAAA,MACF,UAAU;AAAA,MACV,aAAa;AAAA,MACb,UACE;AAAA,MACF,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/parigp-Drow4J0Y.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parigp-Drow4J0Y.js","sources":["../node_modules/refractor/lang/parigp.js"],"sourcesContent":["'use strict'\n\nmodule.exports = parigp\nparigp.displayName = 'parigp'\nparigp.aliases = []\nfunction parigp(Prism) {\n  Prism.languages.parigp = {\n    comment: /\\/\\*[\\s\\S]*?\\*\\/|\\\\\\\\.*/,\n    string: {\n      pattern: /\"(?:[^\"\\\\\\r\\n]|\\\\.)*\"/,\n      greedy: true\n    },\n    // PARI/GP does not care about white spaces at all\n    // so let's process the keywords to build an appropriate regexp\n    // (e.g. \"b *r *e *a *k\", etc.)\n    keyword: (function () {\n      var keywords = [\n        'breakpoint',\n        'break',\n        'dbg_down',\n        'dbg_err',\n        'dbg_up',\n        'dbg_x',\n        'forcomposite',\n        'fordiv',\n        'forell',\n        'forpart',\n        'forprime',\n        'forstep',\n        'forsubgroup',\n        'forvec',\n        'for',\n        'iferr',\n        'if',\n        'local',\n        'my',\n        'next',\n        'return',\n        'until',\n        'while'\n      ]\n      keywords = keywords\n        .map(function (keyword) {\n          return keyword.split('').join(' *')\n        })\n        .join('|')\n      return RegExp('\\\\b(?:' + keywords + ')\\\\b')\n    })(),\n    function: /\\b\\w(?:[\\w ]*\\w)?(?= *\\()/,\n    number: {\n      // The lookbehind and the negative lookahead prevent from breaking the .. operator\n      pattern:\n        /((?:\\. *\\. *)?)(?:\\b\\d(?: *\\d)*(?: *(?!\\. *\\.)\\.(?: *\\d)*)?|\\. *\\d(?: *\\d)*)(?: *e *(?:[+-] *)?\\d(?: *\\d)*)?/i,\n      lookbehind: true\n    },\n    operator:\n      /\\. *\\.|[*\\/!](?: *=)?|%(?: *=|(?: *#)?(?: *')*)?|\\+(?: *[+=])?|-(?: *[-=>])?|<(?: *>|(?: *<)?(?: *=)?)?|>(?: *>)?(?: *=)?|=(?: *=){0,2}|\\\\(?: *\\/)?(?: *=)?|&(?: *&)?|\\| *\\||['#~^]/,\n    punctuation: /[\\[\\]{}().,:;|]/\n  }\n}\n"],"names":["parigp"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAA;AACjB,WAASA,QAAO,OAAO;AACrB,UAAM,UAAU,SAAS;AAAA,MACvB,SAAS;AAAA,MACT,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;;;;MAKV,SAAU,WAAY;AACpB,YAAI,WAAW;AAAA,UACb;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA;AAEF,mBAAW,SACR,IAAI,SAAU,SAAS;AACtB,iBAAO,QAAQ,MAAM,EAAE,EAAE,KAAK,IAAI;AAAA,QAC5C,CAAS,EACA,KAAK,GAAG;AACX,eAAO,OAAO,WAAW,WAAW,MAAM;AAAA,MAChD,EAAK;AAAA,MACD,UAAU;AAAA,MACV,QAAQ;AAAA;AAAA,QAEN,SACE;AAAA,QACF,YAAY;AAAA;MAEd,UACE;AAAA,MACF,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/parser-BMn4dhly.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parser-BMn4dhly.js","sources":["../node_modules/refractor/lang/parser.js"],"sourcesContent":["'use strict'\n\nmodule.exports = parser\nparser.displayName = 'parser'\nparser.aliases = []\nfunction parser(Prism) {\n  ;(function (Prism) {\n    var parser = (Prism.languages.parser = Prism.languages.extend('markup', {\n      keyword: {\n        pattern:\n          /(^|[^^])(?:\\^(?:case|eval|for|if|switch|throw)\\b|@(?:BASE|CLASS|GET(?:_DEFAULT)?|OPTIONS|SET_DEFAULT|USE)\\b)/,\n        lookbehind: true\n      },\n      variable: {\n        pattern: /(^|[^^])\\B\\$(?:\\w+|(?=[.{]))(?:(?:\\.|::?)\\w+)*(?:\\.|::?)?/,\n        lookbehind: true,\n        inside: {\n          punctuation: /\\.|:+/\n        }\n      },\n      function: {\n        pattern: /(^|[^^])\\B[@^]\\w+(?:(?:\\.|::?)\\w+)*(?:\\.|::?)?/,\n        lookbehind: true,\n        inside: {\n          keyword: {\n            pattern: /(^@)(?:GET_|SET_)/,\n            lookbehind: true\n          },\n          punctuation: /\\.|:+/\n        }\n      },\n      escape: {\n        pattern: /\\^(?:[$^;@()\\[\\]{}\"':]|#[a-f\\d]*)/i,\n        alias: 'builtin'\n      },\n      punctuation: /[\\[\\](){};]/\n    }))\n    parser = Prism.languages.insertBefore('parser', 'keyword', {\n      'parser-comment': {\n        pattern: /(\\s)#.*/,\n        lookbehind: true,\n        alias: 'comment'\n      },\n      expression: {\n        // Allow for 3 levels of depth\n        pattern: /(^|[^^])\\((?:[^()]|\\((?:[^()]|\\((?:[^()])*\\))*\\))*\\)/,\n        greedy: true,\n        lookbehind: true,\n        inside: {\n          string: {\n            pattern: /(^|[^^])([\"'])(?:(?!\\2)[^^]|\\^[\\s\\S])*\\2/,\n            lookbehind: true\n          },\n          keyword: parser.keyword,\n          variable: parser.variable,\n          function: parser.function,\n          boolean: /\\b(?:false|true)\\b/,\n          number: /\\b(?:0x[a-f\\d]+|\\d+(?:\\.\\d*)?(?:e[+-]?\\d+)?)\\b/i,\n          escape: parser.escape,\n          operator:\n            /[~+*\\/\\\\%]|!(?:\\|\\|?|=)?|&&?|\\|\\|?|==|<[<=]?|>[>=]?|-[fd]?|\\b(?:def|eq|ge|gt|in|is|le|lt|ne)\\b/,\n          punctuation: parser.punctuation\n        }\n      }\n    })\n    Prism.languages.insertBefore(\n      'inside',\n      'punctuation',\n      {\n        expression: parser.expression,\n        keyword: parser.keyword,\n        variable: parser.variable,\n        function: parser.function,\n        escape: parser.escape,\n        'parser-punctuation': {\n          pattern: parser.punctuation,\n          alias: 'punctuation'\n        }\n      },\n      parser['tag'].inside['attr-value']\n    )\n  })(Prism)\n}\n"],"names":["parser","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAA;AACjB,WAASA,QAAO,OAAO;AACpB,KAAC,SAAUC,QAAO;AACjB,UAAID,UAAUC,OAAM,UAAU,SAASA,OAAM,UAAU,OAAO,UAAU;AAAA,QACtE,SAAS;AAAA,UACP,SACE;AAAA,UACF,YAAY;AAAA;QAEd,UAAU;AAAA,UACR,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN,aAAa;AAAA;;QAGjB,UAAU;AAAA,UACR,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN,SAAS;AAAA,cACP,SAAS;AAAA,cACT,YAAY;AAAA;YAEd,aAAa;AAAA;;QAGjB,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,OAAO;AAAA;QAET,aAAa;AAAA,MACnB,CAAK;AACD,MAAAD,UAASC,OAAM,UAAU,aAAa,UAAU,WAAW;AAAA,QACzD,kBAAkB;AAAA,UAChB,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,OAAO;AAAA;QAET,YAAY;AAAA;AAAA,UAEV,SAAS;AAAA,UACT,QAAQ;AAAA,UACR,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN,QAAQ;AAAA,cACN,SAAS;AAAA,cACT,YAAY;AAAA;YAEd,SAASD,QAAO;AAAA,YAChB,UAAUA,QAAO;AAAA,YACjB,UAAUA,QAAO;AAAA,YACjB,SAAS;AAAA,YACT,QAAQ;AAAA,YACR,QAAQA,QAAO;AAAA,YACf,UACE;AAAA,YACF,aAAaA,QAAO;AAAA;;MAG9B,CAAK;AACD,MAAAC,OAAM,UAAU;AAAA,QACd;AAAA,QACA;AAAA,QACA;AAAA,UACE,YAAYD,QAAO;AAAA,UACnB,SAASA,QAAO;AAAA,UAChB,UAAUA,QAAO;AAAA,UACjB,UAAUA,QAAO;AAAA,UACjB,QAAQA,QAAO;AAAA,UACf,sBAAsB;AAAA,YACpB,SAASA,QAAO;AAAA,YAChB,OAAO;AAAA;;QAGXA,QAAO,KAAK,EAAE,OAAO,YAAY;AAAA;IAEvC,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/pascal-CO60FOZI.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pascal-CO60FOZI.js","sources":["../node_modules/refractor/lang/pascal.js"],"sourcesContent":["'use strict'\n\nmodule.exports = pascal\npascal.displayName = 'pascal'\npascal.aliases = ['objectpascal']\nfunction pascal(Prism) {\n  // Based on Free Pascal\n  /* TODO\nSupport inline asm ?\n*/\n  Prism.languages.pascal = {\n    directive: {\n      pattern: /\\{\\$[\\s\\S]*?\\}/,\n      greedy: true,\n      alias: ['marco', 'property']\n    },\n    comment: {\n      pattern: /\\(\\*[\\s\\S]*?\\*\\)|\\{[\\s\\S]*?\\}|\\/\\/.*/,\n      greedy: true\n    },\n    string: {\n      pattern: /(?:'(?:''|[^'\\r\\n])*'(?!')|#[&$%]?[a-f\\d]+)+|\\^[a-z]/i,\n      greedy: true\n    },\n    asm: {\n      pattern: /(\\basm\\b)[\\s\\S]+?(?=\\bend\\s*[;[])/i,\n      lookbehind: true,\n      greedy: true,\n      inside: null // see below\n    },\n    keyword: [\n      {\n        // Turbo Pascal\n        pattern:\n          /(^|[^&])\\b(?:absolute|array|asm|begin|case|const|constructor|destructor|do|downto|else|end|file|for|function|goto|if|implementation|inherited|inline|interface|label|nil|object|of|operator|packed|procedure|program|record|reintroduce|repeat|self|set|string|then|to|type|unit|until|uses|var|while|with)\\b/i,\n        lookbehind: true\n      },\n      {\n        // Free Pascal\n        pattern: /(^|[^&])\\b(?:dispose|exit|false|new|true)\\b/i,\n        lookbehind: true\n      },\n      {\n        // Object Pascal\n        pattern:\n          /(^|[^&])\\b(?:class|dispinterface|except|exports|finalization|finally|initialization|inline|library|on|out|packed|property|raise|resourcestring|threadvar|try)\\b/i,\n        lookbehind: true\n      },\n      {\n        // Modifiers\n        pattern:\n          /(^|[^&])\\b(?:absolute|abstract|alias|assembler|bitpacked|break|cdecl|continue|cppdecl|cvar|default|deprecated|dynamic|enumerator|experimental|export|external|far|far16|forward|generic|helper|implements|index|interrupt|iochecks|local|message|name|near|nodefault|noreturn|nostackframe|oldfpccall|otherwise|overload|override|pascal|platform|private|protected|public|published|read|register|reintroduce|result|safecall|saveregisters|softfloat|specialize|static|stdcall|stored|strict|unaligned|unimplemented|varargs|virtual|write)\\b/i,\n        lookbehind: true\n      }\n    ],\n    number: [\n      // Hexadecimal, octal and binary\n      /(?:[&%]\\d+|\\$[a-f\\d]+)/i, // Decimal\n      /\\b\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?/i\n    ],\n    operator: [\n      /\\.\\.|\\*\\*|:=|<[<=>]?|>[>=]?|[+\\-*\\/]=?|[@^=]/,\n      {\n        pattern:\n          /(^|[^&])\\b(?:and|as|div|exclude|in|include|is|mod|not|or|shl|shr|xor)\\b/,\n        lookbehind: true\n      }\n    ],\n    punctuation: /\\(\\.|\\.\\)|[()\\[\\]:;,.]/\n  }\n  Prism.languages.pascal.asm.inside = Prism.languages.extend('pascal', {\n    asm: undefined,\n    keyword: undefined,\n    operator: undefined\n  })\n  Prism.languages.objectpascal = Prism.languages.pascal\n}\n"],"names":["pascal"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAC,cAAc;AAChC,WAASA,QAAO,OAAO;AAKrB,UAAM,UAAU,SAAS;AAAA,MACvB,WAAW;AAAA,QACT,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,OAAO,CAAC,SAAS,UAAU;AAAA;MAE7B,SAAS;AAAA,QACP,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,KAAK;AAAA,QACH,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ;AAAA,QACR,QAAQ;AAAA;AAAA;MAEV,SAAS;AAAA,QACP;AAAA;AAAA,UAEE,SACE;AAAA,UACF,YAAY;AAAA;QAEd;AAAA;AAAA,UAEE,SAAS;AAAA,UACT,YAAY;AAAA;QAEd;AAAA;AAAA,UAEE,SACE;AAAA,UACF,YAAY;AAAA;QAEd;AAAA;AAAA,UAEE,SACE;AAAA,UACF,YAAY;AAAA;;MAGhB,QAAQ;AAAA;AAAA,QAEN;AAAA;AAAA,QACA;AAAA;MAEF,UAAU;AAAA,QACR;AAAA,QACA;AAAA,UACE,SACE;AAAA,UACF,YAAY;AAAA;;MAGhB,aAAa;AAAA;AAEf,UAAM,UAAU,OAAO,IAAI,SAAS,MAAM,UAAU,OAAO,UAAU;AAAA,MACnE,KAAK;AAAA,MACL,SAAS;AAAA,MACT,UAAU;AAAA,IACd,CAAG;AACD,UAAM,UAAU,eAAe,MAAM,UAAU;AAAA,EACjD;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/pascaligo-9sdvHRU1.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pascaligo-9sdvHRU1.js","sources":["../node_modules/refractor/lang/pascaligo.js"],"sourcesContent":["'use strict'\n\nmodule.exports = pascaligo\npascaligo.displayName = 'pascaligo'\npascaligo.aliases = []\nfunction pascaligo(Prism) {\n  ;(function (Prism) {\n    // Pascaligo is a layer 2 smart contract language for the tezos blockchain\n    var braces = /\\((?:[^()]|\\((?:[^()]|\\([^()]*\\))*\\))*\\)/.source\n    var type = /(?:\\b\\w+(?:<braces>)?|<braces>)/.source.replace(\n      /<braces>/g,\n      function () {\n        return braces\n      }\n    )\n    var pascaligo = (Prism.languages.pascaligo = {\n      comment: /\\(\\*[\\s\\S]+?\\*\\)|\\/\\/.*/,\n      string: {\n        pattern: /([\"'`])(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1|\\^[a-z]/i,\n        greedy: true\n      },\n      'class-name': [\n        {\n          pattern: RegExp(\n            /(\\btype\\s+\\w+\\s+is\\s+)<type>/.source.replace(\n              /<type>/g,\n              function () {\n                return type\n              }\n            ),\n            'i'\n          ),\n          lookbehind: true,\n          inside: null // see below\n        },\n        {\n          pattern: RegExp(\n            /<type>(?=\\s+is\\b)/.source.replace(/<type>/g, function () {\n              return type\n            }),\n            'i'\n          ),\n          inside: null // see below\n        },\n        {\n          pattern: RegExp(\n            /(:\\s*)<type>/.source.replace(/<type>/g, function () {\n              return type\n            })\n          ),\n          lookbehind: true,\n          inside: null // see below\n        }\n      ],\n      keyword: {\n        pattern:\n          /(^|[^&])\\b(?:begin|block|case|const|else|end|fail|for|from|function|if|is|nil|of|remove|return|skip|then|type|var|while|with)\\b/i,\n        lookbehind: true\n      },\n      boolean: {\n        pattern: /(^|[^&])\\b(?:False|True)\\b/i,\n        lookbehind: true\n      },\n      builtin: {\n        pattern: /(^|[^&])\\b(?:bool|int|list|map|nat|record|string|unit)\\b/i,\n        lookbehind: true\n      },\n      function: /\\b\\w+(?=\\s*\\()/,\n      number: [\n        // Hexadecimal, octal and binary\n        /%[01]+|&[0-7]+|\\$[a-f\\d]+/i, // Decimal\n        /\\b\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?(?:mtz|n)?/i\n      ],\n      operator:\n        /->|=\\/=|\\.\\.|\\*\\*|:=|<[<=>]?|>[>=]?|[+\\-*\\/]=?|[@^=|]|\\b(?:and|mod|or)\\b/,\n      punctuation: /\\(\\.|\\.\\)|[()\\[\\]:;,.{}]/\n    })\n    var classNameInside = [\n      'comment',\n      'keyword',\n      'builtin',\n      'operator',\n      'punctuation'\n    ].reduce(function (accum, key) {\n      accum[key] = pascaligo[key]\n      return accum\n    }, {})\n    pascaligo['class-name'].forEach(function (p) {\n      p.inside = classNameInside\n    })\n  })(Prism)\n}\n"],"names":["pascaligo","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,gBAAiBA;AACjB,EAAAA,WAAU,cAAc;AACxB,EAAAA,WAAU,UAAU,CAAA;AACpB,WAASA,WAAU,OAAO;AACvB,KAAC,SAAUC,QAAO;AAEjB,UAAI,SAAS,2CAA2C;AACxD,UAAI,OAAO,kCAAkC,OAAO;AAAA,QAClD;AAAA,QACA,WAAY;AACV,iBAAO;AAAA,QACf;AAAA;AAEI,UAAID,aAAaC,OAAM,UAAU,YAAY;AAAA,QAC3C,SAAS;AAAA,QACT,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV,cAAc;AAAA,UACZ;AAAA,YACE,SAAS;AAAA,cACP,+BAA+B,OAAO;AAAA,gBACpC;AAAA,gBACA,WAAY;AACV,yBAAO;AAAA,gBACvB;AAAA;cAEY;AAAA;YAEF,YAAY;AAAA,YACZ,QAAQ;AAAA;AAAA;UAEV;AAAA,YACE,SAAS;AAAA,cACP,oBAAoB,OAAO,QAAQ,WAAW,WAAY;AACxD,uBAAO;AAAA,cACrB,CAAa;AAAA,cACD;AAAA;YAEF,QAAQ;AAAA;AAAA;UAEV;AAAA,YACE,SAAS;AAAA,cACP,eAAe,OAAO,QAAQ,WAAW,WAAY;AACnD,uBAAO;AAAA,cACrB,CAAa;AAAA;YAEH,YAAY;AAAA,YACZ,QAAQ;AAAA;AAAA;;QAGZ,SAAS;AAAA,UACP,SACE;AAAA,UACF,YAAY;AAAA;QAEd,SAAS;AAAA,UACP,SAAS;AAAA,UACT,YAAY;AAAA;QAEd,SAAS;AAAA,UACP,SAAS;AAAA,UACT,YAAY;AAAA;QAEd,UAAU;AAAA,QACV,QAAQ;AAAA;AAAA,UAEN;AAAA;AAAA,UACA;AAAA;QAEF,UACE;AAAA,QACF,aAAa;AAAA,MACnB;AACI,UAAI,kBAAkB;AAAA,QACpB;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACN,EAAM,OAAO,SAAU,OAAO,KAAK;AAC7B,cAAM,GAAG,IAAID,WAAU,GAAG;AAC1B,eAAO;AAAA,MACb,GAAO,CAAA,CAAE;AACL,MAAAA,WAAU,YAAY,EAAE,QAAQ,SAAU,GAAG;AAC3C,UAAE,SAAS;AAAA,MACjB,CAAK;AAAA,IACL,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/pcaxis-Bv9axNbU.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pcaxis-Bv9axNbU.js","sources":["../node_modules/refractor/lang/pcaxis.js"],"sourcesContent":["'use strict'\n\nmodule.exports = pcaxis\npcaxis.displayName = 'pcaxis'\npcaxis.aliases = ['px']\nfunction pcaxis(Prism) {\n  Prism.languages.pcaxis = {\n    string: /\"[^\"]*\"/,\n    keyword: {\n      pattern:\n        /((?:^|;)\\s*)[-A-Z\\d]+(?:\\s*\\[[-\\w]+\\])?(?:\\s*\\(\"[^\"]*\"(?:,\\s*\"[^\"]*\")*\\))?(?=\\s*=)/,\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        keyword: /^[-A-Z\\d]+/,\n        language: {\n          pattern: /^(\\s*)\\[[-\\w]+\\]/,\n          lookbehind: true,\n          inside: {\n            punctuation: /^\\[|\\]$/,\n            property: /[-\\w]+/\n          }\n        },\n        'sub-key': {\n          pattern: /^(\\s*)\\S[\\s\\S]*/,\n          lookbehind: true,\n          inside: {\n            parameter: {\n              pattern: /\"[^\"]*\"/,\n              alias: 'property'\n            },\n            punctuation: /^\\(|\\)$|,/\n          }\n        }\n      }\n    },\n    operator: /=/,\n    tlist: {\n      pattern:\n        /TLIST\\s*\\(\\s*\\w+(?:(?:\\s*,\\s*\"[^\"]*\")+|\\s*,\\s*\"[^\"]*\"-\"[^\"]*\")?\\s*\\)/,\n      greedy: true,\n      inside: {\n        function: /^TLIST/,\n        property: {\n          pattern: /^(\\s*\\(\\s*)\\w+/,\n          lookbehind: true\n        },\n        string: /\"[^\"]*\"/,\n        punctuation: /[(),]/,\n        operator: /-/\n      }\n    },\n    punctuation: /[;,]/,\n    number: {\n      pattern: /(^|\\s)\\d+(?:\\.\\d+)?(?!\\S)/,\n      lookbehind: true\n    },\n    boolean: /NO|YES/\n  }\n  Prism.languages.px = Prism.languages.pcaxis\n}\n"],"names":["pcaxis"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAC,IAAI;AACtB,WAASA,QAAO,OAAO;AACrB,UAAM,UAAU,SAAS;AAAA,MACvB,QAAQ;AAAA,MACR,SAAS;AAAA,QACP,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA,QACR,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,UAAU;AAAA,YACR,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,aAAa;AAAA,cACb,UAAU;AAAA;;UAGd,WAAW;AAAA,YACT,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,WAAW;AAAA,gBACT,SAAS;AAAA,gBACT,OAAO;AAAA;cAET,aAAa;AAAA;;;;MAKrB,UAAU;AAAA,MACV,OAAO;AAAA,QACL,SACE;AAAA,QACF,QAAQ;AAAA,QACR,QAAQ;AAAA,UACN,UAAU;AAAA,UACV,UAAU;AAAA,YACR,SAAS;AAAA,YACT,YAAY;AAAA;UAEd,QAAQ;AAAA,UACR,aAAa;AAAA,UACb,UAAU;AAAA;;MAGd,aAAa;AAAA,MACb,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,SAAS;AAAA;AAEX,UAAM,UAAU,KAAK,MAAM,UAAU;AAAA,EACvC;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/peoplecode-C2byWYGK.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"peoplecode-C2byWYGK.js","sources":["../node_modules/refractor/lang/peoplecode.js"],"sourcesContent":["'use strict'\n\nmodule.exports = peoplecode\npeoplecode.displayName = 'peoplecode'\npeoplecode.aliases = ['pcode']\nfunction peoplecode(Prism) {\n  Prism.languages.peoplecode = {\n    comment: RegExp(\n      [\n        // C-style multiline comments\n        /\\/\\*[\\s\\S]*?\\*\\//.source, // REM comments\n        /\\bREM[^;]*;/.source, // Nested <* *> comments\n        /<\\*(?:[^<*]|\\*(?!>)|<(?!\\*)|<\\*(?:(?!\\*>)[\\s\\S])*\\*>)*\\*>/.source, // /+ +/ comments\n        /\\/\\+[\\s\\S]*?\\+\\//.source\n      ].join('|')\n    ),\n    string: {\n      pattern: /'(?:''|[^'\\r\\n])*'(?!')|\"(?:\"\"|[^\"\\r\\n])*\"(?!\")/,\n      greedy: true\n    },\n    variable: /%\\w+/,\n    'function-definition': {\n      pattern: /((?:^|[^\\w-])(?:function|method)\\s+)\\w+/i,\n      lookbehind: true,\n      alias: 'function'\n    },\n    'class-name': {\n      pattern:\n        /((?:^|[^-\\w])(?:as|catch|class|component|create|extends|global|implements|instance|local|of|property|returns)\\s+)\\w+(?::\\w+)*/i,\n      lookbehind: true,\n      inside: {\n        punctuation: /:/\n      }\n    },\n    keyword:\n      /\\b(?:abstract|alias|as|catch|class|component|constant|create|declare|else|end-(?:class|evaluate|for|function|get|if|method|set|try|while)|evaluate|extends|for|function|get|global|if|implements|import|instance|library|local|method|null|of|out|peopleCode|private|program|property|protected|readonly|ref|repeat|returns?|set|step|then|throw|to|try|until|value|when(?:-other)?|while)\\b/i,\n    'operator-keyword': {\n      pattern: /\\b(?:and|not|or)\\b/i,\n      alias: 'operator'\n    },\n    function: /[_a-z]\\w*(?=\\s*\\()/i,\n    boolean: /\\b(?:false|true)\\b/i,\n    number: /\\b\\d+(?:\\.\\d+)?\\b/,\n    operator: /<>|[<>]=?|!=|\\*\\*|[-+*/|=@]/,\n    punctuation: /[:.;,()[\\]]/\n  }\n  Prism.languages.pcode = Prism.languages.peoplecode\n}\n"],"names":["peoplecode"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,iBAAiBA;AACjB,EAAAA,YAAW,cAAc;AACzB,EAAAA,YAAW,UAAU,CAAC,OAAO;AAC7B,WAASA,YAAW,OAAO;AACzB,UAAM,UAAU,aAAa;AAAA,MAC3B,SAAS;AAAA,QACP;AAAA;AAAA,UAEE,mBAAmB;AAAA;AAAA,UACnB,cAAc;AAAA;AAAA,UACd,4DAA4D;AAAA;AAAA,UAC5D,mBAAmB;AAAA,QAC3B,EAAQ,KAAK,GAAG;AAAA;MAEZ,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,UAAU;AAAA,MACV,uBAAuB;AAAA,QACrB,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA;MAET,cAAc;AAAA,QACZ,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA,UACN,aAAa;AAAA;;MAGjB,SACE;AAAA,MACF,oBAAoB;AAAA,QAClB,SAAS;AAAA,QACT,OAAO;AAAA;MAET,UAAU;AAAA,MACV,SAAS;AAAA,MACT,QAAQ;AAAA,MACR,UAAU;AAAA,MACV,aAAa;AAAA;AAEf,UAAM,UAAU,QAAQ,MAAM,UAAU;AAAA,EAC1C;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/perl-CB7qzqed.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"perl-CB7qzqed.js","sources":["../node_modules/refractor/lang/perl.js"],"sourcesContent":["'use strict'\n\nmodule.exports = perl\nperl.displayName = 'perl'\nperl.aliases = []\nfunction perl(Prism) {\n  ;(function (Prism) {\n    var brackets =\n      /(?:\\((?:[^()\\\\]|\\\\[\\s\\S])*\\)|\\{(?:[^{}\\\\]|\\\\[\\s\\S])*\\}|\\[(?:[^[\\]\\\\]|\\\\[\\s\\S])*\\]|<(?:[^<>\\\\]|\\\\[\\s\\S])*>)/\n        .source\n    Prism.languages.perl = {\n      comment: [\n        {\n          // POD\n          pattern: /(^\\s*)=\\w[\\s\\S]*?=cut.*/m,\n          lookbehind: true,\n          greedy: true\n        },\n        {\n          pattern: /(^|[^\\\\$])#.*/,\n          lookbehind: true,\n          greedy: true\n        }\n      ],\n      // TODO Could be nice to handle Heredoc too.\n      string: [\n        {\n          pattern: RegExp(\n            /\\b(?:q|qq|qw|qx)(?![a-zA-Z0-9])\\s*/.source +\n              '(?:' +\n              [\n                // q/.../\n                /([^a-zA-Z0-9\\s{(\\[<])(?:(?!\\1)[^\\\\]|\\\\[\\s\\S])*\\1/.source, // q a...a\n                // eslint-disable-next-line regexp/strict\n                /([a-zA-Z0-9])(?:(?!\\2)[^\\\\]|\\\\[\\s\\S])*\\2/.source, // q(...)\n                // q{...}\n                // q[...]\n                // q<...>\n                brackets\n              ].join('|') +\n              ')'\n          ),\n          greedy: true\n        }, // \"...\", `...`\n        {\n          pattern: /(\"|`)(?:(?!\\1)[^\\\\]|\\\\[\\s\\S])*\\1/,\n          greedy: true\n        }, // '...'\n        // FIXME Multi-line single-quoted strings are not supported as they would break variables containing '\n        {\n          pattern: /'(?:[^'\\\\\\r\\n]|\\\\.)*'/,\n          greedy: true\n        }\n      ],\n      regex: [\n        {\n          pattern: RegExp(\n            /\\b(?:m|qr)(?![a-zA-Z0-9])\\s*/.source +\n              '(?:' +\n              [\n                // m/.../\n                /([^a-zA-Z0-9\\s{(\\[<])(?:(?!\\1)[^\\\\]|\\\\[\\s\\S])*\\1/.source, // m a...a\n                // eslint-disable-next-line regexp/strict\n                /([a-zA-Z0-9])(?:(?!\\2)[^\\\\]|\\\\[\\s\\S])*\\2/.source, // m(...)\n                // m{...}\n                // m[...]\n                // m<...>\n                brackets\n              ].join('|') +\n              ')' +\n              /[msixpodualngc]*/.source\n          ),\n          greedy: true\n        }, // The lookbehinds prevent -s from breaking\n        {\n          pattern: RegExp(\n            /(^|[^-])\\b(?:s|tr|y)(?![a-zA-Z0-9])\\s*/.source +\n              '(?:' +\n              [\n                // s/.../.../\n                // eslint-disable-next-line regexp/strict\n                /([^a-zA-Z0-9\\s{(\\[<])(?:(?!\\2)[^\\\\]|\\\\[\\s\\S])*\\2(?:(?!\\2)[^\\\\]|\\\\[\\s\\S])*\\2/\n                  .source, // s a...a...a\n                // eslint-disable-next-line regexp/strict\n                /([a-zA-Z0-9])(?:(?!\\3)[^\\\\]|\\\\[\\s\\S])*\\3(?:(?!\\3)[^\\\\]|\\\\[\\s\\S])*\\3/\n                  .source, // s(...)(...)\n                // s{...}{...}\n                // s[...][...]\n                // s<...><...>\n                // s(...)[...]\n                brackets + /\\s*/.source + brackets\n              ].join('|') +\n              ')' +\n              /[msixpodualngcer]*/.source\n          ),\n          lookbehind: true,\n          greedy: true\n        }, // /.../\n        // The look-ahead tries to prevent two divisions on\n        // the same line from being highlighted as regex.\n        // This does not support multi-line regex.\n        {\n          pattern:\n            /\\/(?:[^\\/\\\\\\r\\n]|\\\\.)*\\/[msixpodualngc]*(?=\\s*(?:$|[\\r\\n,.;})&|\\-+*~<>!?^]|(?:and|cmp|eq|ge|gt|le|lt|ne|not|or|x|xor)\\b))/,\n          greedy: true\n        }\n      ],\n      // FIXME Not sure about the handling of ::, ', and #\n      variable: [\n        // ${^POSTMATCH}\n        /[&*$@%]\\{\\^[A-Z]+\\}/, // $^V\n        /[&*$@%]\\^[A-Z_]/, // ${...}\n        /[&*$@%]#?(?=\\{)/, // $foo\n        /[&*$@%]#?(?:(?:::)*'?(?!\\d)[\\w$]+(?![\\w$]))+(?:::)*/, // $1\n        /[&*$@%]\\d+/, // $_, @_, %!\n        // The negative lookahead prevents from breaking the %= operator\n        /(?!%=)[$@%][!\"#$%&'()*+,\\-.\\/:;<=>?@[\\\\\\]^_`{|}~]/\n      ],\n      filehandle: {\n        // <>, <FOO>, _\n        pattern: /<(?![<=])\\S*?>|\\b_\\b/,\n        alias: 'symbol'\n      },\n      'v-string': {\n        // v1.2, 1.2.3\n        pattern: /v\\d+(?:\\.\\d+)*|\\d+(?:\\.\\d+){2,}/,\n        alias: 'string'\n      },\n      function: {\n        pattern: /(\\bsub[ \\t]+)\\w+/,\n        lookbehind: true\n      },\n      keyword:\n        /\\b(?:any|break|continue|default|delete|die|do|else|elsif|eval|for|foreach|given|goto|if|last|local|my|next|our|package|print|redo|require|return|say|state|sub|switch|undef|unless|until|use|when|while)\\b/,\n      number:\n        /\\b(?:0x[\\dA-Fa-f](?:_?[\\dA-Fa-f])*|0b[01](?:_?[01])*|(?:(?:\\d(?:_?\\d)*)?\\.)?\\d(?:_?\\d)*(?:[Ee][+-]?\\d+)?)\\b/,\n      operator:\n        /-[rwxoRWXOezsfdlpSbctugkTBMAC]\\b|\\+[+=]?|-[-=>]?|\\*\\*?=?|\\/\\/?=?|=[=~>]?|~[~=]?|\\|\\|?=?|&&?=?|<(?:=>?|<=?)?|>>?=?|![~=]?|[%^]=?|\\.(?:=|\\.\\.?)?|[\\\\?]|\\bx(?:=|\\b)|\\b(?:and|cmp|eq|ge|gt|le|lt|ne|not|or|xor)\\b/,\n      punctuation: /[{}[\\];(),:]/\n    }\n  })(Prism)\n}\n"],"names":["perl","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AAClB,KAAC,SAAUC,QAAO;AACjB,UAAI,WACF,6GACG;AACL,MAAAA,OAAM,UAAU,OAAO;AAAA,QACrB,SAAS;AAAA,UACP;AAAA;AAAA,YAEE,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,QAAQ;AAAA;UAEV;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,QAAQ;AAAA;;;QAIZ,QAAQ;AAAA,UACN;AAAA,YACE,SAAS;AAAA,cACP,qCAAqC,SACnC,QACA;AAAA;AAAA,gBAEE,mDAAmD;AAAA;AAAA;AAAA,gBAEnD,2CAA2C;AAAA;AAAA;AAAA;AAAA;AAAA,gBAI3C;AAAA,cAChB,EAAgB,KAAK,GAAG,IACV;AAAA;YAEJ,QAAQ;AAAA;;UAEV;AAAA,YACE,SAAS;AAAA,YACT,QAAQ;AAAA;;;UAGV;AAAA,YACE,SAAS;AAAA,YACT,QAAQ;AAAA;;QAGZ,OAAO;AAAA,UACL;AAAA,YACE,SAAS;AAAA,cACP,+BAA+B,SAC7B,QACA;AAAA;AAAA,gBAEE,mDAAmD;AAAA;AAAA;AAAA,gBAEnD,2CAA2C;AAAA;AAAA;AAAA;AAAA;AAAA,gBAI3C;AAAA,cAChB,EAAgB,KAAK,GAAG,IACV,MACA,mBAAmB;AAAA;YAEvB,QAAQ;AAAA;;UAEV;AAAA,YACE,SAAS;AAAA,cACP,yCAAyC,SACvC,QACA;AAAA;AAAA;AAAA,gBAGE,8EACG;AAAA;AAAA;AAAA,gBAEH,sEACG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAKH,WAAW,MAAM,SAAS;AAAA,cAC1C,EAAgB,KAAK,GAAG,IACV,MACA,qBAAqB;AAAA;YAEzB,YAAY;AAAA,YACZ,QAAQ;AAAA;;;;;UAKV;AAAA,YACE,SACE;AAAA,YACF,QAAQ;AAAA;;;QAIZ,UAAU;AAAA;AAAA,UAER;AAAA;AAAA,UACA;AAAA;AAAA,UACA;AAAA;AAAA,UACA;AAAA;AAAA,UACA;AAAA;AAAA;AAAA,UAEA;AAAA;QAEF,YAAY;AAAA;AAAA,UAEV,SAAS;AAAA,UACT,OAAO;AAAA;QAET,YAAY;AAAA;AAAA,UAEV,SAAS;AAAA,UACT,OAAO;AAAA;QAET,UAAU;AAAA,UACR,SAAS;AAAA,UACT,YAAY;AAAA;QAEd,SACE;AAAA,QACF,QACE;AAAA,QACF,UACE;AAAA,QACF,aAAa;AAAA;IAEnB,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/php-BBLqus8v.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"php-BBLqus8v.js","sources":["../node_modules/refractor/lang/php.js"],"sourcesContent":["'use strict'\nvar refractorMarkupTemplating = require('./markup-templating.js')\nmodule.exports = php\nphp.displayName = 'php'\nphp.aliases = []\nfunction php(Prism) {\n  Prism.register(refractorMarkupTemplating)\n  /**\n   * Original by Aaron Harun: http://aahacreative.com/2012/07/31/php-syntax-highlighting-prism/\n   * Modified by Miles Johnson: http://milesj.me\n   * Rewritten by Tom Pavelec\n   *\n   * Supports PHP 5.3 - 8.0\n   */\n  ;(function (Prism) {\n    var comment = /\\/\\*[\\s\\S]*?\\*\\/|\\/\\/.*|#(?!\\[).*/\n    var constant = [\n      {\n        pattern: /\\b(?:false|true)\\b/i,\n        alias: 'boolean'\n      },\n      {\n        pattern: /(::\\s*)\\b[a-z_]\\w*\\b(?!\\s*\\()/i,\n        greedy: true,\n        lookbehind: true\n      },\n      {\n        pattern: /(\\b(?:case|const)\\s+)\\b[a-z_]\\w*(?=\\s*[;=])/i,\n        greedy: true,\n        lookbehind: true\n      },\n      /\\b(?:null)\\b/i,\n      /\\b[A-Z_][A-Z0-9_]*\\b(?!\\s*\\()/\n    ]\n    var number =\n      /\\b0b[01]+(?:_[01]+)*\\b|\\b0o[0-7]+(?:_[0-7]+)*\\b|\\b0x[\\da-f]+(?:_[\\da-f]+)*\\b|(?:\\b\\d+(?:_\\d+)*\\.?(?:\\d+(?:_\\d+)*)?|\\B\\.\\d+)(?:e[+-]?\\d+)?/i\n    var operator =\n      /<?=>|\\?\\?=?|\\.{3}|\\??->|[!=]=?=?|::|\\*\\*=?|--|\\+\\+|&&|\\|\\||<<|>>|[?~]|[/^|%*&<>.+-]=?/\n    var punctuation = /[{}\\[\\](),:;]/\n    Prism.languages.php = {\n      delimiter: {\n        pattern: /\\?>$|^<\\?(?:php(?=\\s)|=)?/i,\n        alias: 'important'\n      },\n      comment: comment,\n      variable: /\\$+(?:\\w+\\b|(?=\\{))/,\n      package: {\n        pattern:\n          /(namespace\\s+|use\\s+(?:function\\s+)?)(?:\\\\?\\b[a-z_]\\w*)+\\b(?!\\\\)/i,\n        lookbehind: true,\n        inside: {\n          punctuation: /\\\\/\n        }\n      },\n      'class-name-definition': {\n        pattern: /(\\b(?:class|enum|interface|trait)\\s+)\\b[a-z_]\\w*(?!\\\\)\\b/i,\n        lookbehind: true,\n        alias: 'class-name'\n      },\n      'function-definition': {\n        pattern: /(\\bfunction\\s+)[a-z_]\\w*(?=\\s*\\()/i,\n        lookbehind: true,\n        alias: 'function'\n      },\n      keyword: [\n        {\n          pattern:\n            /(\\(\\s*)\\b(?:array|bool|boolean|float|int|integer|object|string)\\b(?=\\s*\\))/i,\n          alias: 'type-casting',\n          greedy: true,\n          lookbehind: true\n        },\n        {\n          pattern:\n            /([(,?]\\s*)\\b(?:array(?!\\s*\\()|bool|callable|(?:false|null)(?=\\s*\\|)|float|int|iterable|mixed|object|self|static|string)\\b(?=\\s*\\$)/i,\n          alias: 'type-hint',\n          greedy: true,\n          lookbehind: true\n        },\n        {\n          pattern:\n            /(\\)\\s*:\\s*(?:\\?\\s*)?)\\b(?:array(?!\\s*\\()|bool|callable|(?:false|null)(?=\\s*\\|)|float|int|iterable|mixed|object|self|static|string|void)\\b/i,\n          alias: 'return-type',\n          greedy: true,\n          lookbehind: true\n        },\n        {\n          pattern:\n            /\\b(?:array(?!\\s*\\()|bool|float|int|iterable|mixed|object|string|void)\\b/i,\n          alias: 'type-declaration',\n          greedy: true\n        },\n        {\n          pattern: /(\\|\\s*)(?:false|null)\\b|\\b(?:false|null)(?=\\s*\\|)/i,\n          alias: 'type-declaration',\n          greedy: true,\n          lookbehind: true\n        },\n        {\n          pattern: /\\b(?:parent|self|static)(?=\\s*::)/i,\n          alias: 'static-context',\n          greedy: true\n        },\n        {\n          // yield from\n          pattern: /(\\byield\\s+)from\\b/i,\n          lookbehind: true\n        }, // `class` is always a keyword unlike other keywords\n        /\\bclass\\b/i,\n        {\n          // https://www.php.net/manual/en/reserved.keywords.php\n          //\n          // keywords cannot be preceded by \"->\"\n          // the complex lookbehind means `(?<!(?:->|::)\\s*)`\n          pattern:\n            /((?:^|[^\\s>:]|(?:^|[^-])>|(?:^|[^:]):)\\s*)\\b(?:abstract|and|array|as|break|callable|case|catch|clone|const|continue|declare|default|die|do|echo|else|elseif|empty|enddeclare|endfor|endforeach|endif|endswitch|endwhile|enum|eval|exit|extends|final|finally|fn|for|foreach|function|global|goto|if|implements|include|include_once|instanceof|insteadof|interface|isset|list|match|namespace|new|or|parent|print|private|protected|public|require|require_once|return|self|static|switch|throw|trait|try|unset|use|var|while|xor|yield|__halt_compiler)\\b/i,\n          lookbehind: true\n        }\n      ],\n      'argument-name': {\n        pattern: /([(,]\\s+)\\b[a-z_]\\w*(?=\\s*:(?!:))/i,\n        lookbehind: true\n      },\n      'class-name': [\n        {\n          pattern:\n            /(\\b(?:extends|implements|instanceof|new(?!\\s+self|\\s+static))\\s+|\\bcatch\\s*\\()\\b[a-z_]\\w*(?!\\\\)\\b/i,\n          greedy: true,\n          lookbehind: true\n        },\n        {\n          pattern: /(\\|\\s*)\\b[a-z_]\\w*(?!\\\\)\\b/i,\n          greedy: true,\n          lookbehind: true\n        },\n        {\n          pattern: /\\b[a-z_]\\w*(?!\\\\)\\b(?=\\s*\\|)/i,\n          greedy: true\n        },\n        {\n          pattern: /(\\|\\s*)(?:\\\\?\\b[a-z_]\\w*)+\\b/i,\n          alias: 'class-name-fully-qualified',\n          greedy: true,\n          lookbehind: true,\n          inside: {\n            punctuation: /\\\\/\n          }\n        },\n        {\n          pattern: /(?:\\\\?\\b[a-z_]\\w*)+\\b(?=\\s*\\|)/i,\n          alias: 'class-name-fully-qualified',\n          greedy: true,\n          inside: {\n            punctuation: /\\\\/\n          }\n        },\n        {\n          pattern:\n            /(\\b(?:extends|implements|instanceof|new(?!\\s+self\\b|\\s+static\\b))\\s+|\\bcatch\\s*\\()(?:\\\\?\\b[a-z_]\\w*)+\\b(?!\\\\)/i,\n          alias: 'class-name-fully-qualified',\n          greedy: true,\n          lookbehind: true,\n          inside: {\n            punctuation: /\\\\/\n          }\n        },\n        {\n          pattern: /\\b[a-z_]\\w*(?=\\s*\\$)/i,\n          alias: 'type-declaration',\n          greedy: true\n        },\n        {\n          pattern: /(?:\\\\?\\b[a-z_]\\w*)+(?=\\s*\\$)/i,\n          alias: ['class-name-fully-qualified', 'type-declaration'],\n          greedy: true,\n          inside: {\n            punctuation: /\\\\/\n          }\n        },\n        {\n          pattern: /\\b[a-z_]\\w*(?=\\s*::)/i,\n          alias: 'static-context',\n          greedy: true\n        },\n        {\n          pattern: /(?:\\\\?\\b[a-z_]\\w*)+(?=\\s*::)/i,\n          alias: ['class-name-fully-qualified', 'static-context'],\n          greedy: true,\n          inside: {\n            punctuation: /\\\\/\n          }\n        },\n        {\n          pattern: /([(,?]\\s*)[a-z_]\\w*(?=\\s*\\$)/i,\n          alias: 'type-hint',\n          greedy: true,\n          lookbehind: true\n        },\n        {\n          pattern: /([(,?]\\s*)(?:\\\\?\\b[a-z_]\\w*)+(?=\\s*\\$)/i,\n          alias: ['class-name-fully-qualified', 'type-hint'],\n          greedy: true,\n          lookbehind: true,\n          inside: {\n            punctuation: /\\\\/\n          }\n        },\n        {\n          pattern: /(\\)\\s*:\\s*(?:\\?\\s*)?)\\b[a-z_]\\w*(?!\\\\)\\b/i,\n          alias: 'return-type',\n          greedy: true,\n          lookbehind: true\n        },\n        {\n          pattern: /(\\)\\s*:\\s*(?:\\?\\s*)?)(?:\\\\?\\b[a-z_]\\w*)+\\b(?!\\\\)/i,\n          alias: ['class-name-fully-qualified', 'return-type'],\n          greedy: true,\n          lookbehind: true,\n          inside: {\n            punctuation: /\\\\/\n          }\n        }\n      ],\n      constant: constant,\n      function: {\n        pattern: /(^|[^\\\\\\w])\\\\?[a-z_](?:[\\w\\\\]*\\w)?(?=\\s*\\()/i,\n        lookbehind: true,\n        inside: {\n          punctuation: /\\\\/\n        }\n      },\n      property: {\n        pattern: /(->\\s*)\\w+/,\n        lookbehind: true\n      },\n      number: number,\n      operator: operator,\n      punctuation: punctuation\n    }\n    var string_interpolation = {\n      pattern:\n        /\\{\\$(?:\\{(?:\\{[^{}]+\\}|[^{}]+)\\}|[^{}])+\\}|(^|[^\\\\{])\\$+(?:\\w+(?:\\[[^\\r\\n\\[\\]]+\\]|->\\w+)?)/,\n      lookbehind: true,\n      inside: Prism.languages.php\n    }\n    var string = [\n      {\n        pattern: /<<<'([^']+)'[\\r\\n](?:.*[\\r\\n])*?\\1;/,\n        alias: 'nowdoc-string',\n        greedy: true,\n        inside: {\n          delimiter: {\n            pattern: /^<<<'[^']+'|[a-z_]\\w*;$/i,\n            alias: 'symbol',\n            inside: {\n              punctuation: /^<<<'?|[';]$/\n            }\n          }\n        }\n      },\n      {\n        pattern:\n          /<<<(?:\"([^\"]+)\"[\\r\\n](?:.*[\\r\\n])*?\\1;|([a-z_]\\w*)[\\r\\n](?:.*[\\r\\n])*?\\2;)/i,\n        alias: 'heredoc-string',\n        greedy: true,\n        inside: {\n          delimiter: {\n            pattern: /^<<<(?:\"[^\"]+\"|[a-z_]\\w*)|[a-z_]\\w*;$/i,\n            alias: 'symbol',\n            inside: {\n              punctuation: /^<<<\"?|[\";]$/\n            }\n          },\n          interpolation: string_interpolation\n        }\n      },\n      {\n        pattern: /`(?:\\\\[\\s\\S]|[^\\\\`])*`/,\n        alias: 'backtick-quoted-string',\n        greedy: true\n      },\n      {\n        pattern: /'(?:\\\\[\\s\\S]|[^\\\\'])*'/,\n        alias: 'single-quoted-string',\n        greedy: true\n      },\n      {\n        pattern: /\"(?:\\\\[\\s\\S]|[^\\\\\"])*\"/,\n        alias: 'double-quoted-string',\n        greedy: true,\n        inside: {\n          interpolation: string_interpolation\n        }\n      }\n    ]\n    Prism.languages.insertBefore('php', 'variable', {\n      string: string,\n      attribute: {\n        pattern:\n          /#\\[(?:[^\"'\\/#]|\\/(?![*/])|\\/\\/.*$|#(?!\\[).*$|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/|\"(?:\\\\[\\s\\S]|[^\\\\\"])*\"|'(?:\\\\[\\s\\S]|[^\\\\'])*')+\\](?=\\s*[a-z$#])/im,\n        greedy: true,\n        inside: {\n          'attribute-content': {\n            pattern: /^(#\\[)[\\s\\S]+(?=\\]$)/,\n            lookbehind: true,\n            // inside can appear subset of php\n            inside: {\n              comment: comment,\n              string: string,\n              'attribute-class-name': [\n                {\n                  pattern: /([^:]|^)\\b[a-z_]\\w*(?!\\\\)\\b/i,\n                  alias: 'class-name',\n                  greedy: true,\n                  lookbehind: true\n                },\n                {\n                  pattern: /([^:]|^)(?:\\\\?\\b[a-z_]\\w*)+/i,\n                  alias: ['class-name', 'class-name-fully-qualified'],\n                  greedy: true,\n                  lookbehind: true,\n                  inside: {\n                    punctuation: /\\\\/\n                  }\n                }\n              ],\n              constant: constant,\n              number: number,\n              operator: operator,\n              punctuation: punctuation\n            }\n          },\n          delimiter: {\n            pattern: /^#\\[|\\]$/,\n            alias: 'punctuation'\n          }\n        }\n      }\n    })\n    Prism.hooks.add('before-tokenize', function (env) {\n      if (!/<\\?/.test(env.code)) {\n        return\n      }\n      var phpPattern =\n        /<\\?(?:[^\"'/#]|\\/(?![*/])|(\"|')(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1|(?:\\/\\/|#(?!\\[))(?:[^?\\n\\r]|\\?(?!>))*(?=$|\\?>|[\\r\\n])|#\\[|\\/\\*(?:[^*]|\\*(?!\\/))*(?:\\*\\/|$))*?(?:\\?>|$)/g\n      Prism.languages['markup-templating'].buildPlaceholders(\n        env,\n        'php',\n        phpPattern\n      )\n    })\n    Prism.hooks.add('after-tokenize', function (env) {\n      Prism.languages['markup-templating'].tokenizePlaceholders(env, 'php')\n    })\n  })(Prism)\n}\n"],"names":["require$$0","Prism"],"mappings":";;;;;;AACA,MAAI,4BAA4BA,wBAAA;AAChC,UAAiB;AACjB,MAAI,cAAc;AAClB,MAAI,UAAU,CAAA;AACd,WAAS,IAAI,OAAO;AAClB,UAAM,SAAS,yBAAyB;AAQvC,KAAC,SAAUC,QAAO;AACjB,UAAI,UAAU;AACd,UAAI,WAAW;AAAA,QACb;AAAA,UACE,SAAS;AAAA,UACT,OAAO;AAAA;QAET;AAAA,UACE,SAAS;AAAA,UACT,QAAQ;AAAA,UACR,YAAY;AAAA;QAEd;AAAA,UACE,SAAS;AAAA,UACT,QAAQ;AAAA,UACR,YAAY;AAAA;QAEd;AAAA,QACA;AAAA;AAEF,UAAI,SACF;AACF,UAAI,WACF;AACF,UAAI,cAAc;AAClB,MAAAA,OAAM,UAAU,MAAM;AAAA,QACpB,WAAW;AAAA,UACT,SAAS;AAAA,UACT,OAAO;AAAA;QAET;AAAA,QACA,UAAU;AAAA,QACV,SAAS;AAAA,UACP,SACE;AAAA,UACF,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN,aAAa;AAAA;;QAGjB,yBAAyB;AAAA,UACvB,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,OAAO;AAAA;QAET,uBAAuB;AAAA,UACrB,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,OAAO;AAAA;QAET,SAAS;AAAA,UACP;AAAA,YACE,SACE;AAAA,YACF,OAAO;AAAA,YACP,QAAQ;AAAA,YACR,YAAY;AAAA;UAEd;AAAA,YACE,SACE;AAAA,YACF,OAAO;AAAA,YACP,QAAQ;AAAA,YACR,YAAY;AAAA;UAEd;AAAA,YACE,SACE;AAAA,YACF,OAAO;AAAA,YACP,QAAQ;AAAA,YACR,YAAY;AAAA;UAEd;AAAA,YACE,SACE;AAAA,YACF,OAAO;AAAA,YACP,QAAQ;AAAA;UAEV;AAAA,YACE,SAAS;AAAA,YACT,OAAO;AAAA,YACP,QAAQ;AAAA,YACR,YAAY;AAAA;UAEd;AAAA,YACE,SAAS;AAAA,YACT,OAAO;AAAA,YACP,QAAQ;AAAA;UAEV;AAAA;AAAA,YAEE,SAAS;AAAA,YACT,YAAY;AAAA;;UAEd;AAAA,UACA;AAAA;AAAA;AAAA;AAAA;AAAA,YAKE,SACE;AAAA,YACF,YAAY;AAAA;;QAGhB,iBAAiB;AAAA,UACf,SAAS;AAAA,UACT,YAAY;AAAA;QAEd,cAAc;AAAA,UACZ;AAAA,YACE,SACE;AAAA,YACF,QAAQ;AAAA,YACR,YAAY;AAAA;UAEd;AAAA,YACE,SAAS;AAAA,YACT,QAAQ;AAAA,YACR,YAAY;AAAA;UAEd;AAAA,YACE,SAAS;AAAA,YACT,QAAQ;AAAA;UAEV;AAAA,YACE,SAAS;AAAA,YACT,OAAO;AAAA,YACP,QAAQ;AAAA,YACR,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,aAAa;AAAA;;UAGjB;AAAA,YACE,SAAS;AAAA,YACT,OAAO;AAAA,YACP,QAAQ;AAAA,YACR,QAAQ;AAAA,cACN,aAAa;AAAA;;UAGjB;AAAA,YACE,SACE;AAAA,YACF,OAAO;AAAA,YACP,QAAQ;AAAA,YACR,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,aAAa;AAAA;;UAGjB;AAAA,YACE,SAAS;AAAA,YACT,OAAO;AAAA,YACP,QAAQ;AAAA;UAEV;AAAA,YACE,SAAS;AAAA,YACT,OAAO,CAAC,8BAA8B,kBAAkB;AAAA,YACxD,QAAQ;AAAA,YACR,QAAQ;AAAA,cACN,aAAa;AAAA;;UAGjB;AAAA,YACE,SAAS;AAAA,YACT,OAAO;AAAA,YACP,QAAQ;AAAA;UAEV;AAAA,YACE,SAAS;AAAA,YACT,OAAO,CAAC,8BAA8B,gBAAgB;AAAA,YACtD,QAAQ;AAAA,YACR,QAAQ;AAAA,cACN,aAAa;AAAA;;UAGjB;AAAA,YACE,SAAS;AAAA,YACT,OAAO;AAAA,YACP,QAAQ;AAAA,YACR,YAAY;AAAA;UAEd;AAAA,YACE,SAAS;AAAA,YACT,OAAO,CAAC,8BAA8B,WAAW;AAAA,YACjD,QAAQ;AAAA,YACR,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,aAAa;AAAA;;UAGjB;AAAA,YACE,SAAS;AAAA,YACT,OAAO;AAAA,YACP,QAAQ;AAAA,YACR,YAAY;AAAA;UAEd;AAAA,YACE,SAAS;AAAA,YACT,OAAO,CAAC,8BAA8B,aAAa;AAAA,YACnD,QAAQ;AAAA,YACR,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,aAAa;AAAA;;;QAInB;AAAA,QACA,UAAU;AAAA,UACR,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN,aAAa;AAAA;;QAGjB,UAAU;AAAA,UACR,SAAS;AAAA,UACT,YAAY;AAAA;QAEd;AAAA,QACA;AAAA,QACA;AAAA;AAEF,UAAI,uBAAuB;AAAA,QACzB,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQA,OAAM,UAAU;AAAA;AAE1B,UAAI,SAAS;AAAA,QACX;AAAA,UACE,SAAS;AAAA,UACT,OAAO;AAAA,UACP,QAAQ;AAAA,UACR,QAAQ;AAAA,YACN,WAAW;AAAA,cACT,SAAS;AAAA,cACT,OAAO;AAAA,cACP,QAAQ;AAAA,gBACN,aAAa;AAAA;;;;QAKrB;AAAA,UACE,SACE;AAAA,UACF,OAAO;AAAA,UACP,QAAQ;AAAA,UACR,QAAQ;AAAA,YACN,WAAW;AAAA,cACT,SAAS;AAAA,cACT,OAAO;AAAA,cACP,QAAQ;AAAA,gBACN,aAAa;AAAA;;YAGjB,eAAe;AAAA;;QAGnB;AAAA,UACE,SAAS;AAAA,UACT,OAAO;AAAA,UACP,QAAQ;AAAA;QAEV;AAAA,UACE,SAAS;AAAA,UACT,OAAO;AAAA,UACP,QAAQ;AAAA;QAEV;AAAA,UACE,SAAS;AAAA,UACT,OAAO;AAAA,UACP,QAAQ;AAAA,UACR,QAAQ;AAAA,YACN,eAAe;AAAA;;;AAIrB,MAAAA,OAAM,UAAU,aAAa,OAAO,YAAY;AAAA,QAC9C;AAAA,QACA,WAAW;AAAA,UACT,SACE;AAAA,UACF,QAAQ;AAAA,UACR,QAAQ;AAAA,YACN,qBAAqB;AAAA,cACnB,SAAS;AAAA,cACT,YAAY;AAAA;AAAA,cAEZ,QAAQ;AAAA,gBACN;AAAA,gBACA;AAAA,gBACA,wBAAwB;AAAA,kBACtB;AAAA,oBACE,SAAS;AAAA,oBACT,OAAO;AAAA,oBACP,QAAQ;AAAA,oBACR,YAAY;AAAA;kBAEd;AAAA,oBACE,SAAS;AAAA,oBACT,OAAO,CAAC,cAAc,4BAA4B;AAAA,oBAClD,QAAQ;AAAA,oBACR,YAAY;AAAA,oBACZ,QAAQ;AAAA,sBACN,aAAa;AAAA;;;gBAInB;AAAA,gBACA;AAAA,gBACA;AAAA,gBACA;AAAA;;YAGJ,WAAW;AAAA,cACT,SAAS;AAAA,cACT,OAAO;AAAA;;;MAInB,CAAK;AACD,MAAAA,OAAM,MAAM,IAAI,mBAAmB,SAAU,KAAK;AAChD,YAAI,CAAC,MAAM,KAAK,IAAI,IAAI,GAAG;AACzB;AAAA,QACR;AACM,YAAI,aACF;AACF,QAAAA,OAAM,UAAU,mBAAmB,EAAE;AAAA,UACnC;AAAA,UACA;AAAA,UACA;AAAA;MAER,CAAK;AACD,MAAAA,OAAM,MAAM,IAAI,kBAAkB,SAAU,KAAK;AAC/C,QAAAA,OAAM,UAAU,mBAAmB,EAAE,qBAAqB,KAAK,KAAK;AAAA,MAC1E,CAAK;AAAA,IACL,GAAK,KAAK;AAAA,EACV;;;","x_google_ignoreList":[0]}

package/dist/php-BLzy7UZ5.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"php-BLzy7UZ5.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/php-extras-B9cfv_-s.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"php-extras-B9cfv_-s.js","sources":["../node_modules/refractor/lang/php-extras.js"],"sourcesContent":["'use strict'\nvar refractorPhp = require('./php.js')\nmodule.exports = phpExtras\nphpExtras.displayName = 'phpExtras'\nphpExtras.aliases = []\nfunction phpExtras(Prism) {\n  Prism.register(refractorPhp)\n  Prism.languages.insertBefore('php', 'variable', {\n    this: {\n      pattern: /\\$this\\b/,\n      alias: 'keyword'\n    },\n    global:\n      /\\$(?:GLOBALS|HTTP_RAW_POST_DATA|_(?:COOKIE|ENV|FILES|GET|POST|REQUEST|SERVER|SESSION)|argc|argv|http_response_header|php_errormsg)\\b/,\n    scope: {\n      pattern: /\\b[\\w\\\\]+::/,\n      inside: {\n        keyword: /\\b(?:parent|self|static)\\b/,\n        punctuation: /::|\\\\/\n      }\n    }\n  })\n}\n"],"names":["require$$0","phpExtras"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,eAAeA,WAAA;AACnB,gBAAiBC;AACjB,EAAAA,WAAU,cAAc;AACxB,EAAAA,WAAU,UAAU,CAAA;AACpB,WAASA,WAAU,OAAO;AACxB,UAAM,SAAS,YAAY;AAC3B,UAAM,UAAU,aAAa,OAAO,YAAY;AAAA,MAC9C,MAAM;AAAA,QACJ,SAAS;AAAA,QACT,OAAO;AAAA;MAET,QACE;AAAA,MACF,OAAO;AAAA,QACL,SAAS;AAAA,QACT,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,aAAa;AAAA;;IAGrB,CAAG;AAAA,EACH;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/phpdoc-C-t0vPc3.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"phpdoc-C-t0vPc3.js","sources":["../node_modules/refractor/lang/phpdoc.js"],"sourcesContent":["'use strict'\nvar refractorPhp = require('./php.js')\nvar refractorJavadoclike = require('./javadoclike.js')\nmodule.exports = phpdoc\nphpdoc.displayName = 'phpdoc'\nphpdoc.aliases = []\nfunction phpdoc(Prism) {\n  Prism.register(refractorPhp)\n  Prism.register(refractorJavadoclike)\n  ;(function (Prism) {\n    var typeExpression = /(?:\\b[a-zA-Z]\\w*|[|\\\\[\\]])+/.source\n    Prism.languages.phpdoc = Prism.languages.extend('javadoclike', {\n      parameter: {\n        pattern: RegExp(\n          '(@(?:global|param|property(?:-read|-write)?|var)\\\\s+(?:' +\n            typeExpression +\n            '\\\\s+)?)\\\\$\\\\w+'\n        ),\n        lookbehind: true\n      }\n    })\n    Prism.languages.insertBefore('phpdoc', 'keyword', {\n      'class-name': [\n        {\n          pattern: RegExp(\n            '(@(?:global|package|param|property(?:-read|-write)?|return|subpackage|throws|var)\\\\s+)' +\n              typeExpression\n          ),\n          lookbehind: true,\n          inside: {\n            keyword:\n              /\\b(?:array|bool|boolean|callback|double|false|float|int|integer|mixed|null|object|resource|self|string|true|void)\\b/,\n            punctuation: /[|\\\\[\\]()]/\n          }\n        }\n      ]\n    })\n    Prism.languages.javadoclike.addSupport('php', Prism.languages.phpdoc)\n  })(Prism)\n}\n"],"names":["require$$0","require$$1","phpdoc","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,eAAeA,WAAA;AACnB,MAAI,uBAAuBC,mBAAA;AAC3B,aAAiBC;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAA;AACjB,WAASA,QAAO,OAAO;AACrB,UAAM,SAAS,YAAY;AAC3B,UAAM,SAAS,oBAAoB;AAClC,KAAC,SAAUC,QAAO;AACjB,UAAI,iBAAiB,8BAA8B;AACnD,MAAAA,OAAM,UAAU,SAASA,OAAM,UAAU,OAAO,eAAe;AAAA,QAC7D,WAAW;AAAA,UACT,SAAS;AAAA,YACP,4DACE,iBACA;AAAA;UAEJ,YAAY;AAAA;MAEpB,CAAK;AACD,MAAAA,OAAM,UAAU,aAAa,UAAU,WAAW;AAAA,QAChD,cAAc;AAAA,UACZ;AAAA,YACE,SAAS;AAAA,cACP,2FACE;AAAA;YAEJ,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,SACE;AAAA,cACF,aAAa;AAAA;;;MAIzB,CAAK;AACD,MAAAA,OAAM,UAAU,YAAY,WAAW,OAAOA,OAAM,UAAU,MAAM;AAAA,IACxE,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/plsql-DiW7USdU.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"plsql-DiW7USdU.js","sources":["../node_modules/refractor/lang/plsql.js"],"sourcesContent":["'use strict'\nvar refractorSql = require('./sql.js')\nmodule.exports = plsql\nplsql.displayName = 'plsql'\nplsql.aliases = []\nfunction plsql(Prism) {\n  Prism.register(refractorSql)\n  Prism.languages.plsql = Prism.languages.extend('sql', {\n    comment: {\n      pattern: /\\/\\*[\\s\\S]*?\\*\\/|--.*/,\n      greedy: true\n    },\n    // https://docs.oracle.com/en/database/oracle/oracle-database/21/lnpls/plsql-reserved-words-keywords.html\n    keyword:\n      /\\b(?:A|ACCESSIBLE|ADD|AGENT|AGGREGATE|ALL|ALTER|AND|ANY|ARRAY|AS|ASC|AT|ATTRIBUTE|AUTHID|AVG|BEGIN|BETWEEN|BFILE_BASE|BINARY|BLOB_BASE|BLOCK|BODY|BOTH|BOUND|BULK|BY|BYTE|C|CALL|CALLING|CASCADE|CASE|CHAR|CHARACTER|CHARSET|CHARSETFORM|CHARSETID|CHAR_BASE|CHECK|CLOB_BASE|CLONE|CLOSE|CLUSTER|CLUSTERS|COLAUTH|COLLECT|COLUMNS|COMMENT|COMMIT|COMMITTED|COMPILED|COMPRESS|CONNECT|CONSTANT|CONSTRUCTOR|CONTEXT|CONTINUE|CONVERT|COUNT|CRASH|CREATE|CREDENTIAL|CURRENT|CURSOR|CUSTOMDATUM|DANGLING|DATA|DATE|DATE_BASE|DAY|DECLARE|DEFAULT|DEFINE|DELETE|DESC|DETERMINISTIC|DIRECTORY|DISTINCT|DOUBLE|DROP|DURATION|ELEMENT|ELSE|ELSIF|EMPTY|END|ESCAPE|EXCEPT|EXCEPTION|EXCEPTIONS|EXCLUSIVE|EXECUTE|EXISTS|EXIT|EXTERNAL|FETCH|FINAL|FIRST|FIXED|FLOAT|FOR|FORALL|FORCE|FROM|FUNCTION|GENERAL|GOTO|GRANT|GROUP|HASH|HAVING|HEAP|HIDDEN|HOUR|IDENTIFIED|IF|IMMEDIATE|IMMUTABLE|IN|INCLUDING|INDEX|INDEXES|INDICATOR|INDICES|INFINITE|INSERT|INSTANTIABLE|INT|INTERFACE|INTERSECT|INTERVAL|INTO|INVALIDATE|IS|ISOLATION|JAVA|LANGUAGE|LARGE|LEADING|LENGTH|LEVEL|LIBRARY|LIKE|LIKE2|LIKE4|LIKEC|LIMIT|LIMITED|LOCAL|LOCK|LONG|LOOP|MAP|MAX|MAXLEN|MEMBER|MERGE|MIN|MINUS|MINUTE|MOD|MODE|MODIFY|MONTH|MULTISET|MUTABLE|NAME|NAN|NATIONAL|NATIVE|NCHAR|NEW|NOCOMPRESS|NOCOPY|NOT|NOWAIT|NULL|NUMBER_BASE|OBJECT|OCICOLL|OCIDATE|OCIDATETIME|OCIDURATION|OCIINTERVAL|OCILOBLOCATOR|OCINUMBER|OCIRAW|OCIREF|OCIREFCURSOR|OCIROWID|OCISTRING|OCITYPE|OF|OLD|ON|ONLY|OPAQUE|OPEN|OPERATOR|OPTION|OR|ORACLE|ORADATA|ORDER|ORGANIZATION|ORLANY|ORLVARY|OTHERS|OUT|OVERLAPS|OVERRIDING|PACKAGE|PARALLEL_ENABLE|PARAMETER|PARAMETERS|PARENT|PARTITION|PASCAL|PERSISTABLE|PIPE|PIPELINED|PLUGGABLE|POLYMORPHIC|PRAGMA|PRECISION|PRIOR|PRIVATE|PROCEDURE|PUBLIC|RAISE|RANGE|RAW|READ|RECORD|REF|REFERENCE|RELIES_ON|REM|REMAINDER|RENAME|RESOURCE|RESULT|RESULT_CACHE|RETURN|RETURNING|REVERSE|REVOKE|ROLLBACK|ROW|SAMPLE|SAVE|SAVEPOINT|SB1|SB2|SB4|SECOND|SEGMENT|SELECT|SELF|SEPARATE|SEQUENCE|SERIALIZABLE|SET|SHARE|SHORT|SIZE|SIZE_T|SOME|SPARSE|SQL|SQLCODE|SQLDATA|SQLNAME|SQLSTATE|STANDARD|START|STATIC|STDDEV|STORED|STRING|STRUCT|STYLE|SUBMULTISET|SUBPARTITION|SUBSTITUTABLE|SUBTYPE|SUM|SYNONYM|TABAUTH|TABLE|TDO|THE|THEN|TIME|TIMESTAMP|TIMEZONE_ABBR|TIMEZONE_HOUR|TIMEZONE_MINUTE|TIMEZONE_REGION|TO|TRAILING|TRANSACTION|TRANSACTIONAL|TRUSTED|TYPE|UB1|UB2|UB4|UNDER|UNION|UNIQUE|UNPLUG|UNSIGNED|UNTRUSTED|UPDATE|USE|USING|VALIST|VALUE|VALUES|VARIABLE|VARIANCE|VARRAY|VARYING|VIEW|VIEWS|VOID|WHEN|WHERE|WHILE|WITH|WORK|WRAPPED|WRITE|YEAR|ZONE)\\b/i,\n    // https://docs.oracle.com/en/database/oracle/oracle-database/21/lnpls/plsql-language-fundamentals.html#GUID-96A42F7C-7A71-4B90-8255-CA9C8BD9722E\n    operator: /:=?|=>|[<>^~!]=|\\.\\.|\\|\\||\\*\\*|[-+*/%<>=@]/\n  })\n  Prism.languages.insertBefore('plsql', 'operator', {\n    label: {\n      pattern: /<<\\s*\\w+\\s*>>/,\n      alias: 'symbol'\n    }\n  })\n}\n"],"names":["require$$0","plsql"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,eAAeA,WAAA;AACnB,YAAiBC;AACjB,EAAAA,OAAM,cAAc;AACpB,EAAAA,OAAM,UAAU,CAAA;AAChB,WAASA,OAAM,OAAO;AACpB,UAAM,SAAS,YAAY;AAC3B,UAAM,UAAU,QAAQ,MAAM,UAAU,OAAO,OAAO;AAAA,MACpD,SAAS;AAAA,QACP,SAAS;AAAA,QACT,QAAQ;AAAA;;MAGV,SACE;AAAA;AAAA,MAEF,UAAU;AAAA,IACd,CAAG;AACD,UAAM,UAAU,aAAa,SAAS,YAAY;AAAA,MAChD,OAAO;AAAA,QACL,SAAS;AAAA,QACT,OAAO;AAAA;IAEb,CAAG;AAAA,EACH;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/powerquery-D6cLp7LV.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"powerquery-D6cLp7LV.js","sources":["../node_modules/refractor/lang/powerquery.js"],"sourcesContent":["'use strict'\n\nmodule.exports = powerquery\npowerquery.displayName = 'powerquery'\npowerquery.aliases = []\nfunction powerquery(Prism) {\n  // https://docs.microsoft.com/en-us/powerquery-m/power-query-m-language-specification\n  Prism.languages.powerquery = {\n    comment: {\n      pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?\\*\\/|\\/\\/.*)/,\n      lookbehind: true,\n      greedy: true\n    },\n    'quoted-identifier': {\n      pattern: /#\"(?:[^\"\\r\\n]|\"\")*\"(?!\")/,\n      greedy: true\n    },\n    string: {\n      pattern: /(?:#!)?\"(?:[^\"\\r\\n]|\"\")*\"(?!\")/,\n      greedy: true\n    },\n    constant: [\n      /\\bDay\\.(?:Friday|Monday|Saturday|Sunday|Thursday|Tuesday|Wednesday)\\b/,\n      /\\bTraceLevel\\.(?:Critical|Error|Information|Verbose|Warning)\\b/,\n      /\\bOccurrence\\.(?:All|First|Last)\\b/,\n      /\\bOrder\\.(?:Ascending|Descending)\\b/,\n      /\\bRoundingMode\\.(?:AwayFromZero|Down|ToEven|TowardZero|Up)\\b/,\n      /\\bMissingField\\.(?:Error|Ignore|UseNull)\\b/,\n      /\\bQuoteStyle\\.(?:Csv|None)\\b/,\n      /\\bJoinKind\\.(?:FullOuter|Inner|LeftAnti|LeftOuter|RightAnti|RightOuter)\\b/,\n      /\\bGroupKind\\.(?:Global|Local)\\b/,\n      /\\bExtraValues\\.(?:Error|Ignore|List)\\b/,\n      /\\bJoinAlgorithm\\.(?:Dynamic|LeftHash|LeftIndex|PairwiseHash|RightHash|RightIndex|SortMerge)\\b/,\n      /\\bJoinSide\\.(?:Left|Right)\\b/,\n      /\\bPrecision\\.(?:Decimal|Double)\\b/,\n      /\\bRelativePosition\\.From(?:End|Start)\\b/,\n      /\\bTextEncoding\\.(?:Ascii|BigEndianUnicode|Unicode|Utf16|Utf8|Windows)\\b/,\n      /\\b(?:Any|Binary|Date|DateTime|DateTimeZone|Duration|Function|Int16|Int32|Int64|Int8|List|Logical|None|Number|Record|Table|Text|Time)\\.Type\\b/,\n      /\\bnull\\b/\n    ],\n    boolean: /\\b(?:false|true)\\b/,\n    keyword:\n      /\\b(?:and|as|each|else|error|if|in|is|let|meta|not|nullable|optional|or|otherwise|section|shared|then|try|type)\\b|#(?:binary|date|datetime|datetimezone|duration|infinity|nan|sections|shared|table|time)\\b/,\n    function: {\n      pattern: /(^|[^#\\w.])[a-z_][\\w.]*(?=\\s*\\()/i,\n      lookbehind: true\n    },\n    'data-type': {\n      pattern:\n        /\\b(?:any|anynonnull|binary|date|datetime|datetimezone|duration|function|list|logical|none|number|record|table|text|time)\\b/,\n      alias: 'class-name'\n    },\n    number: {\n      pattern:\n        /\\b0x[\\da-f]+\\b|(?:[+-]?(?:\\b\\d+\\.)?\\b\\d+|[+-]\\.\\d+|(^|[^.])\\B\\.\\d+)(?:e[+-]?\\d+)?\\b/i,\n      lookbehind: true\n    },\n    operator: /[-+*\\/&?@^]|<(?:=>?|>)?|>=?|=>?|\\.\\.\\.?/,\n    punctuation: /[,;\\[\\](){}]/\n  }\n  Prism.languages.pq = Prism.languages['powerquery']\n  Prism.languages.mscript = Prism.languages['powerquery']\n}\n"],"names":["powerquery"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,iBAAiBA;AACjB,EAAAA,YAAW,cAAc;AACzB,EAAAA,YAAW,UAAU,CAAA;AACrB,WAASA,YAAW,OAAO;AAEzB,UAAM,UAAU,aAAa;AAAA,MAC3B,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ;AAAA;MAEV,qBAAqB;AAAA,QACnB,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,UAAU;AAAA,QACR;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA;MAEF,SAAS;AAAA,MACT,SACE;AAAA,MACF,UAAU;AAAA,QACR,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,aAAa;AAAA,QACX,SACE;AAAA,QACF,OAAO;AAAA;MAET,QAAQ;AAAA,QACN,SACE;AAAA,QACF,YAAY;AAAA;MAEd,UAAU;AAAA,MACV,aAAa;AAAA;AAEf,UAAM,UAAU,KAAK,MAAM,UAAU,YAAY;AACjD,UAAM,UAAU,UAAU,MAAM,UAAU,YAAY;AAAA,EACxD;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/powershell-DYnJupW9.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"powershell-DYnJupW9.js","sources":["../node_modules/refractor/lang/powershell.js"],"sourcesContent":["'use strict'\n\nmodule.exports = powershell\npowershell.displayName = 'powershell'\npowershell.aliases = []\nfunction powershell(Prism) {\n  ;(function (Prism) {\n    var powershell = (Prism.languages.powershell = {\n      comment: [\n        {\n          pattern: /(^|[^`])<#[\\s\\S]*?#>/,\n          lookbehind: true\n        },\n        {\n          pattern: /(^|[^`])#.*/,\n          lookbehind: true\n        }\n      ],\n      string: [\n        {\n          pattern: /\"(?:`[\\s\\S]|[^`\"])*\"/,\n          greedy: true,\n          inside: null // see below\n        },\n        {\n          pattern: /'(?:[^']|'')*'/,\n          greedy: true\n        }\n      ],\n      // Matches name spaces as well as casts, attribute decorators. Force starting with letter to avoid matching array indices\n      // Supports two levels of nested brackets (e.g. `[OutputType([System.Collections.Generic.List[int]])]`)\n      namespace: /\\[[a-z](?:\\[(?:\\[[^\\]]*\\]|[^\\[\\]])*\\]|[^\\[\\]])*\\]/i,\n      boolean: /\\$(?:false|true)\\b/i,\n      variable: /\\$\\w+\\b/,\n      // Cmdlets and aliases. Aliases should come last, otherwise \"write\" gets preferred over \"write-host\" for example\n      // Get-Command | ?{ $_.ModuleName -match \"Microsoft.PowerShell.(Util|Core|Management)\" }\n      // Get-Alias | ?{ $_.ReferencedCommand.Module.Name -match \"Microsoft.PowerShell.(Util|Core|Management)\" }\n      function: [\n        /\\b(?:Add|Approve|Assert|Backup|Block|Checkpoint|Clear|Close|Compare|Complete|Compress|Confirm|Connect|Convert|ConvertFrom|ConvertTo|Copy|Debug|Deny|Disable|Disconnect|Dismount|Edit|Enable|Enter|Exit|Expand|Export|Find|ForEach|Format|Get|Grant|Group|Hide|Import|Initialize|Install|Invoke|Join|Limit|Lock|Measure|Merge|Move|New|Open|Optimize|Out|Ping|Pop|Protect|Publish|Push|Read|Receive|Redo|Register|Remove|Rename|Repair|Request|Reset|Resize|Resolve|Restart|Restore|Resume|Revoke|Save|Search|Select|Send|Set|Show|Skip|Sort|Split|Start|Step|Stop|Submit|Suspend|Switch|Sync|Tee|Test|Trace|Unblock|Undo|Uninstall|Unlock|Unprotect|Unpublish|Unregister|Update|Use|Wait|Watch|Where|Write)-[a-z]+\\b/i,\n        /\\b(?:ac|cat|chdir|clc|cli|clp|clv|compare|copy|cp|cpi|cpp|cvpa|dbp|del|diff|dir|ebp|echo|epal|epcsv|epsn|erase|fc|fl|ft|fw|gal|gbp|gc|gci|gcs|gdr|gi|gl|gm|gp|gps|group|gsv|gu|gv|gwmi|iex|ii|ipal|ipcsv|ipsn|irm|iwmi|iwr|kill|lp|ls|measure|mi|mount|move|mp|mv|nal|ndr|ni|nv|ogv|popd|ps|pushd|pwd|rbp|rd|rdr|ren|ri|rm|rmdir|rni|rnp|rp|rv|rvpa|rwmi|sal|saps|sasv|sbp|sc|select|set|shcm|si|sl|sleep|sls|sort|sp|spps|spsv|start|sv|swmi|tee|trcm|type|write)\\b/i\n      ],\n      // per http://technet.microsoft.com/en-us/library/hh847744.aspx\n      keyword:\n        /\\b(?:Begin|Break|Catch|Class|Continue|Data|Define|Do|DynamicParam|Else|ElseIf|End|Exit|Filter|Finally|For|ForEach|From|Function|If|InlineScript|Parallel|Param|Process|Return|Sequence|Switch|Throw|Trap|Try|Until|Using|Var|While|Workflow)\\b/i,\n      operator: {\n        pattern:\n          /(^|\\W)(?:!|-(?:b?(?:and|x?or)|as|(?:Not)?(?:Contains|In|Like|Match)|eq|ge|gt|is(?:Not)?|Join|le|lt|ne|not|Replace|sh[lr])\\b|-[-=]?|\\+[+=]?|[*\\/%]=?)/i,\n        lookbehind: true\n      },\n      punctuation: /[|{}[\\];(),.]/\n    }) // Variable interpolation inside strings, and nested expressions\n    powershell.string[0].inside = {\n      function: {\n        // Allow for one level of nesting\n        pattern: /(^|[^`])\\$\\((?:\\$\\([^\\r\\n()]*\\)|(?!\\$\\()[^\\r\\n)])*\\)/,\n        lookbehind: true,\n        inside: powershell\n      },\n      boolean: powershell.boolean,\n      variable: powershell.variable\n    }\n  })(Prism)\n}\n"],"names":["powershell","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,iBAAiBA;AACjB,EAAAA,YAAW,cAAc;AACzB,EAAAA,YAAW,UAAU,CAAA;AACrB,WAASA,YAAW,OAAO;AACxB,KAAC,SAAUC,QAAO;AACjB,UAAID,cAAcC,OAAM,UAAU,aAAa;AAAA,QAC7C,SAAS;AAAA,UACP;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA;UAEd;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA;;QAGhB,QAAQ;AAAA,UACN;AAAA,YACE,SAAS;AAAA,YACT,QAAQ;AAAA,YACR,QAAQ;AAAA;AAAA;UAEV;AAAA,YACE,SAAS;AAAA,YACT,QAAQ;AAAA;;;;QAKZ,WAAW;AAAA,QACX,SAAS;AAAA,QACT,UAAU;AAAA;AAAA;AAAA;AAAA,QAIV,UAAU;AAAA,UACR;AAAA,UACA;AAAA;;QAGF,SACE;AAAA,QACF,UAAU;AAAA,UACR,SACE;AAAA,UACF,YAAY;AAAA;QAEd,aAAa;AAAA,MACnB;AACI,MAAAD,YAAW,OAAO,CAAC,EAAE,SAAS;AAAA,QAC5B,UAAU;AAAA;AAAA,UAER,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQA;AAAA;QAEV,SAASA,YAAW;AAAA,QACpB,UAAUA,YAAW;AAAA;IAE3B,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/processing-CEjrszl5.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"processing-CEjrszl5.js","sources":["../node_modules/refractor/lang/processing.js"],"sourcesContent":["'use strict'\n\nmodule.exports = processing\nprocessing.displayName = 'processing'\nprocessing.aliases = []\nfunction processing(Prism) {\n  Prism.languages.processing = Prism.languages.extend('clike', {\n    keyword:\n      /\\b(?:break|case|catch|class|continue|default|else|extends|final|for|if|implements|import|new|null|private|public|return|static|super|switch|this|try|void|while)\\b/,\n    // Spaces are allowed between function name and parenthesis\n    function: /\\b\\w+(?=\\s*\\()/,\n    operator: /<[<=]?|>[>=]?|&&?|\\|\\|?|[%?]|[!=+\\-*\\/]=?/\n  })\n  Prism.languages.insertBefore('processing', 'number', {\n    // Special case: XML is a type\n    constant: /\\b(?!XML\\b)[A-Z][A-Z\\d_]+\\b/,\n    type: {\n      pattern: /\\b(?:boolean|byte|char|color|double|float|int|[A-Z]\\w*)\\b/,\n      alias: 'class-name'\n    }\n  })\n}\n"],"names":["processing"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,iBAAiBA;AACjB,EAAAA,YAAW,cAAc;AACzB,EAAAA,YAAW,UAAU,CAAA;AACrB,WAASA,YAAW,OAAO;AACzB,UAAM,UAAU,aAAa,MAAM,UAAU,OAAO,SAAS;AAAA,MAC3D,SACE;AAAA;AAAA,MAEF,UAAU;AAAA,MACV,UAAU;AAAA,IACd,CAAG;AACD,UAAM,UAAU,aAAa,cAAc,UAAU;AAAA;AAAA,MAEnD,UAAU;AAAA,MACV,MAAM;AAAA,QACJ,SAAS;AAAA,QACT,OAAO;AAAA;IAEb,CAAG;AAAA,EACH;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/prolog-Bhtm0Ucy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"prolog-Bhtm0Ucy.js","sources":["../node_modules/refractor/lang/prolog.js"],"sourcesContent":["'use strict'\n\nmodule.exports = prolog\nprolog.displayName = 'prolog'\nprolog.aliases = []\nfunction prolog(Prism) {\n  Prism.languages.prolog = {\n    // Syntax depends on the implementation\n    comment: {\n      pattern: /\\/\\*[\\s\\S]*?\\*\\/|%.*/,\n      greedy: true\n    },\n    // Depending on the implementation, strings may allow escaped newlines and quote-escape\n    string: {\n      pattern: /([\"'])(?:\\1\\1|\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1(?!\\1)/,\n      greedy: true\n    },\n    builtin: /\\b(?:fx|fy|xf[xy]?|yfx?)\\b/,\n    // FIXME: Should we list all null-ary predicates (not followed by a parenthesis) like halt, trace, etc.?\n    function: /\\b[a-z]\\w*(?:(?=\\()|\\/\\d+)/,\n    number: /\\b\\d+(?:\\.\\d*)?/,\n    // Custom operators are allowed\n    operator: /[:\\\\=><\\-?*@\\/;+^|!$.]+|\\b(?:is|mod|not|xor)\\b/,\n    punctuation: /[(){}\\[\\],]/\n  }\n}\n"],"names":["prolog"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAA;AACjB,WAASA,QAAO,OAAO;AACrB,UAAM,UAAU,SAAS;AAAA;AAAA,MAEvB,SAAS;AAAA,QACP,SAAS;AAAA,QACT,QAAQ;AAAA;;MAGV,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,SAAS;AAAA;AAAA,MAET,UAAU;AAAA,MACV,QAAQ;AAAA;AAAA,MAER,UAAU;AAAA,MACV,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/promql-CKj1N3Qa.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"promql-CKj1N3Qa.js","sources":["../node_modules/refractor/lang/promql.js"],"sourcesContent":["'use strict'\n\nmodule.exports = promql\npromql.displayName = 'promql'\npromql.aliases = []\nfunction promql(Prism) {\n  // Thanks to: https://github.com/prometheus-community/monaco-promql/blob/master/src/promql/promql.ts\n  // As well as: https://kausal.co/blog/slate-prism-add-new-syntax-promql/\n  ;(function (Prism) {\n    // PromQL Aggregation Operators\n    // (https://prometheus.io/docs/prometheus/latest/querying/operators/#aggregation-operators)\n    var aggregations = [\n      'sum',\n      'min',\n      'max',\n      'avg',\n      'group',\n      'stddev',\n      'stdvar',\n      'count',\n      'count_values',\n      'bottomk',\n      'topk',\n      'quantile'\n    ] // PromQL vector matching + the by and without clauses\n    // (https://prometheus.io/docs/prometheus/latest/querying/operators/#vector-matching)\n    var vectorMatching = [\n      'on',\n      'ignoring',\n      'group_right',\n      'group_left',\n      'by',\n      'without'\n    ] // PromQL offset modifier\n    // (https://prometheus.io/docs/prometheus/latest/querying/basics/#offset-modifier)\n    var offsetModifier = ['offset']\n    var keywords = aggregations.concat(vectorMatching, offsetModifier)\n    Prism.languages.promql = {\n      comment: {\n        pattern: /(^[ \\t]*)#.*/m,\n        lookbehind: true\n      },\n      'vector-match': {\n        // Match the comma-separated label lists inside vector matching:\n        pattern: new RegExp(\n          '((?:' + vectorMatching.join('|') + ')\\\\s*)\\\\([^)]*\\\\)'\n        ),\n        lookbehind: true,\n        inside: {\n          'label-key': {\n            pattern: /\\b[^,]+\\b/,\n            alias: 'attr-name'\n          },\n          punctuation: /[(),]/\n        }\n      },\n      'context-labels': {\n        pattern: /\\{[^{}]*\\}/,\n        inside: {\n          'label-key': {\n            pattern: /\\b[a-z_]\\w*(?=\\s*(?:=|![=~]))/,\n            alias: 'attr-name'\n          },\n          'label-value': {\n            pattern: /([\"'`])(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1/,\n            greedy: true,\n            alias: 'attr-value'\n          },\n          punctuation: /\\{|\\}|=~?|![=~]|,/\n        }\n      },\n      'context-range': [\n        {\n          pattern: /\\[[\\w\\s:]+\\]/,\n          // [1m]\n          inside: {\n            punctuation: /\\[|\\]|:/,\n            'range-duration': {\n              pattern: /\\b(?:\\d+(?:[smhdwy]|ms))+\\b/i,\n              alias: 'number'\n            }\n          }\n        },\n        {\n          pattern: /(\\boffset\\s+)\\w+/,\n          // offset 1m\n          lookbehind: true,\n          inside: {\n            'range-duration': {\n              pattern: /\\b(?:\\d+(?:[smhdwy]|ms))+\\b/i,\n              alias: 'number'\n            }\n          }\n        }\n      ],\n      keyword: new RegExp('\\\\b(?:' + keywords.join('|') + ')\\\\b', 'i'),\n      function: /\\b[a-z_]\\w*(?=\\s*\\()/i,\n      number:\n        /[-+]?(?:(?:\\b\\d+(?:\\.\\d+)?|\\B\\.\\d+)(?:e[-+]?\\d+)?\\b|\\b(?:0x[0-9a-f]+|nan|inf)\\b)/i,\n      operator: /[\\^*/%+-]|==|!=|<=|<|>=|>|\\b(?:and|or|unless)\\b/i,\n      punctuation: /[{};()`,.[\\]]/\n    }\n  })(Prism)\n}\n"],"names":["promql","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAA;AACjB,WAASA,QAAO,OAAO;AAGpB,KAAC,SAAUC,QAAO;AAGjB,UAAI,eAAe;AAAA,QACjB;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA;AAGF,UAAI,iBAAiB;AAAA,QACnB;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA;AAGF,UAAI,iBAAiB,CAAC,QAAQ;AAC9B,UAAI,WAAW,aAAa,OAAO,gBAAgB,cAAc;AACjE,MAAAA,OAAM,UAAU,SAAS;AAAA,QACvB,SAAS;AAAA,UACP,SAAS;AAAA,UACT,YAAY;AAAA;QAEd,gBAAgB;AAAA;AAAA,UAEd,SAAS,IAAI;AAAA,YACX,SAAS,eAAe,KAAK,GAAG,IAAI;AAAA;UAEtC,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN,aAAa;AAAA,cACX,SAAS;AAAA,cACT,OAAO;AAAA;YAET,aAAa;AAAA;;QAGjB,kBAAkB;AAAA,UAChB,SAAS;AAAA,UACT,QAAQ;AAAA,YACN,aAAa;AAAA,cACX,SAAS;AAAA,cACT,OAAO;AAAA;YAET,eAAe;AAAA,cACb,SAAS;AAAA,cACT,QAAQ;AAAA,cACR,OAAO;AAAA;YAET,aAAa;AAAA;;QAGjB,iBAAiB;AAAA,UACf;AAAA,YACE,SAAS;AAAA;AAAA,YAET,QAAQ;AAAA,cACN,aAAa;AAAA,cACb,kBAAkB;AAAA,gBAChB,SAAS;AAAA,gBACT,OAAO;AAAA;;;UAIb;AAAA,YACE,SAAS;AAAA;AAAA,YAET,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,kBAAkB;AAAA,gBAChB,SAAS;AAAA,gBACT,OAAO;AAAA;;;;QAKf,SAAS,IAAI,OAAO,WAAW,SAAS,KAAK,GAAG,IAAI,QAAQ,GAAG;AAAA,QAC/D,UAAU;AAAA,QACV,QACE;AAAA,QACF,UAAU;AAAA,QACV,aAAa;AAAA;IAEnB,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/properties-CC4acQoP.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"properties-CC4acQoP.js","sources":["../node_modules/refractor/lang/properties.js"],"sourcesContent":["'use strict'\n\nmodule.exports = properties\nproperties.displayName = 'properties'\nproperties.aliases = []\nfunction properties(Prism) {\n  Prism.languages.properties = {\n    comment: /^[ \\t]*[#!].*$/m,\n    'attr-value': {\n      pattern:\n        /(^[ \\t]*(?:\\\\(?:\\r\\n|[\\s\\S])|[^\\\\\\s:=])+(?: *[=:] *(?! )| ))(?:\\\\(?:\\r\\n|[\\s\\S])|[^\\\\\\r\\n])+/m,\n      lookbehind: true\n    },\n    'attr-name': /^[ \\t]*(?:\\\\(?:\\r\\n|[\\s\\S])|[^\\\\\\s:=])+(?= *[=:]| )/m,\n    punctuation: /[=:]/\n  }\n}\n"],"names":["properties"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,iBAAiBA;AACjB,EAAAA,YAAW,cAAc;AACzB,EAAAA,YAAW,UAAU,CAAA;AACrB,WAASA,YAAW,OAAO;AACzB,UAAM,UAAU,aAAa;AAAA,MAC3B,SAAS;AAAA,MACT,cAAc;AAAA,QACZ,SACE;AAAA,QACF,YAAY;AAAA;MAEd,aAAa;AAAA,MACb,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/protobuf-KD3IiDXx.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"protobuf-KD3IiDXx.js","sources":["../node_modules/refractor/lang/protobuf.js"],"sourcesContent":["'use strict'\n\nmodule.exports = protobuf\nprotobuf.displayName = 'protobuf'\nprotobuf.aliases = []\nfunction protobuf(Prism) {\n  ;(function (Prism) {\n    var builtinTypes =\n      /\\b(?:bool|bytes|double|s?fixed(?:32|64)|float|[su]?int(?:32|64)|string)\\b/\n    Prism.languages.protobuf = Prism.languages.extend('clike', {\n      'class-name': [\n        {\n          pattern:\n            /(\\b(?:enum|extend|message|service)\\s+)[A-Za-z_]\\w*(?=\\s*\\{)/,\n          lookbehind: true\n        },\n        {\n          pattern:\n            /(\\b(?:rpc\\s+\\w+|returns)\\s*\\(\\s*(?:stream\\s+)?)\\.?[A-Za-z_]\\w*(?:\\.[A-Za-z_]\\w*)*(?=\\s*\\))/,\n          lookbehind: true\n        }\n      ],\n      keyword:\n        /\\b(?:enum|extend|extensions|import|message|oneof|option|optional|package|public|repeated|required|reserved|returns|rpc(?=\\s+\\w)|service|stream|syntax|to)\\b(?!\\s*=\\s*\\d)/,\n      function: /\\b[a-z_]\\w*(?=\\s*\\()/i\n    })\n    Prism.languages.insertBefore('protobuf', 'operator', {\n      map: {\n        pattern: /\\bmap<\\s*[\\w.]+\\s*,\\s*[\\w.]+\\s*>(?=\\s+[a-z_]\\w*\\s*[=;])/i,\n        alias: 'class-name',\n        inside: {\n          punctuation: /[<>.,]/,\n          builtin: builtinTypes\n        }\n      },\n      builtin: builtinTypes,\n      'positional-class-name': {\n        pattern: /(?:\\b|\\B\\.)[a-z_]\\w*(?:\\.[a-z_]\\w*)*(?=\\s+[a-z_]\\w*\\s*[=;])/i,\n        alias: 'class-name',\n        inside: {\n          punctuation: /\\./\n        }\n      },\n      annotation: {\n        pattern: /(\\[\\s*)[a-z_]\\w*(?=\\s*=)/i,\n        lookbehind: true\n      }\n    })\n  })(Prism)\n}\n"],"names":["protobuf","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,eAAiBA;AACjB,EAAAA,UAAS,cAAc;AACvB,EAAAA,UAAS,UAAU,CAAA;AACnB,WAASA,UAAS,OAAO;AACtB,KAAC,SAAUC,QAAO;AACjB,UAAI,eACF;AACF,MAAAA,OAAM,UAAU,WAAWA,OAAM,UAAU,OAAO,SAAS;AAAA,QACzD,cAAc;AAAA,UACZ;AAAA,YACE,SACE;AAAA,YACF,YAAY;AAAA;UAEd;AAAA,YACE,SACE;AAAA,YACF,YAAY;AAAA;;QAGhB,SACE;AAAA,QACF,UAAU;AAAA,MAChB,CAAK;AACD,MAAAA,OAAM,UAAU,aAAa,YAAY,YAAY;AAAA,QACnD,KAAK;AAAA,UACH,SAAS;AAAA,UACT,OAAO;AAAA,UACP,QAAQ;AAAA,YACN,aAAa;AAAA,YACb,SAAS;AAAA;;QAGb,SAAS;AAAA,QACT,yBAAyB;AAAA,UACvB,SAAS;AAAA,UACT,OAAO;AAAA,UACP,QAAQ;AAAA,YACN,aAAa;AAAA;;QAGjB,YAAY;AAAA,UACV,SAAS;AAAA,UACT,YAAY;AAAA;MAEpB,CAAK;AAAA,IACL,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/psl-DWQm9K3F.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"psl-DWQm9K3F.js","sources":["../node_modules/refractor/lang/psl.js"],"sourcesContent":["'use strict'\n\nmodule.exports = psl\npsl.displayName = 'psl'\npsl.aliases = []\nfunction psl(Prism) {\n  Prism.languages.psl = {\n    comment: {\n      pattern: /#.*/,\n      greedy: true\n    },\n    string: {\n      pattern: /\"(?:\\\\.|[^\\\\\"])*\"/,\n      greedy: true,\n      inside: {\n        symbol: /\\\\[ntrbA-Z\"\\\\]/\n      }\n    },\n    'heredoc-string': {\n      pattern: /<<<([a-zA-Z_]\\w*)[\\r\\n](?:.*[\\r\\n])*?\\1\\b/,\n      alias: 'string',\n      greedy: true\n    },\n    keyword:\n      /\\b(?:__multi|__single|case|default|do|else|elsif|exit|export|for|foreach|function|if|last|line|local|next|requires|return|switch|until|while|word)\\b/,\n    constant:\n      /\\b(?:ALARM|CHART_ADD_GRAPH|CHART_DELETE_GRAPH|CHART_DESTROY|CHART_LOAD|CHART_PRINT|EOF|OFFLINE|OK|PSL_PROF_LOG|R_CHECK_HORIZ|R_CHECK_VERT|R_CLICKER|R_COLUMN|R_FRAME|R_ICON|R_LABEL|R_LABEL_CENTER|R_LIST_MULTIPLE|R_LIST_MULTIPLE_ND|R_LIST_SINGLE|R_LIST_SINGLE_ND|R_MENU|R_POPUP|R_POPUP_SCROLLED|R_RADIO_HORIZ|R_RADIO_VERT|R_ROW|R_SCALE_HORIZ|R_SCALE_VERT|R_SEP_HORIZ|R_SEP_VERT|R_SPINNER|R_TEXT_FIELD|R_TEXT_FIELD_LABEL|R_TOGGLE|TRIM_LEADING|TRIM_LEADING_AND_TRAILING|TRIM_REDUNDANT|TRIM_TRAILING|VOID|WARN)\\b/,\n    boolean: /\\b(?:FALSE|False|NO|No|TRUE|True|YES|Yes|false|no|true|yes)\\b/,\n    variable: /\\b(?:PslDebug|errno|exit_status)\\b/,\n    builtin: {\n      pattern:\n        /\\b(?:PslExecute|PslFunctionCall|PslFunctionExists|PslSetOptions|_snmp_debug|acos|add_diary|annotate|annotate_get|ascii_to_ebcdic|asctime|asin|atan|atexit|batch_set|blackout|cat|ceil|chan_exists|change_state|close|code_cvt|cond_signal|cond_wait|console_type|convert_base|convert_date|convert_locale_date|cos|cosh|create|date|dcget_text|destroy|destroy_lock|dget_text|difference|dump_hist|ebcdic_to_ascii|encrypt|event_archive|event_catalog_get|event_check|event_query|event_range_manage|event_range_query|event_report|event_schedule|event_trigger|event_trigger2|execute|exists|exp|fabs|file|floor|fmod|fopen|fseek|ftell|full_discovery|get|get_chan_info|get_ranges|get_text|get_vars|getenv|gethostinfo|getpid|getpname|grep|history|history_get_retention|in_transition|index|int|internal|intersection|is_var|isnumber|join|kill|length|lines|lock|lock_info|log|log10|loge|matchline|msg_check|msg_get_format|msg_get_severity|msg_printf|msg_sprintf|ntharg|nthargf|nthline|nthlinef|num_bytes|num_consoles|pconfig|popen|poplines|pow|print|printf|proc_exists|process|random|read|readln|refresh_parameters|remote_check|remote_close|remote_event_query|remote_event_trigger|remote_file_send|remote_open|remove|replace|rindex|sec_check_priv|sec_store_get|sec_store_set|set|set_alarm_ranges|set_locale|share|sin|sinh|sleep|snmp_agent_config|snmp_agent_start|snmp_agent_stop|snmp_close|snmp_config|snmp_get|snmp_get_next|snmp_h_get|snmp_h_get_next|snmp_h_set|snmp_open|snmp_set|snmp_trap_ignore|snmp_trap_listen|snmp_trap_raise_std_trap|snmp_trap_receive|snmp_trap_register_im|snmp_trap_send|snmp_walk|sopen|sort|splitline|sprintf|sqrt|srandom|str_repeat|strcasecmp|subset|substr|system|tail|tan|tanh|text_domain|time|tmpnam|tolower|toupper|trace_psl_process|trim|union|unique|unlock|unset|va_arg|va_start|write)\\b/,\n      alias: 'builtin-function'\n    },\n    'foreach-variable': {\n      pattern:\n        /(\\bforeach\\s+(?:(?:\\w+\\b|\"(?:\\\\.|[^\\\\\"])*\")\\s+){0,2})[_a-zA-Z]\\w*(?=\\s*\\()/,\n      lookbehind: true,\n      greedy: true\n    },\n    function: /\\b[_a-z]\\w*\\b(?=\\s*\\()/i,\n    number: /\\b(?:0x[0-9a-f]+|\\d+(?:\\.\\d+)?)\\b/i,\n    operator: /--|\\+\\+|&&=?|\\|\\|=?|<<=?|>>=?|[=!]~|[-+*/%&|^!=<>]=?|\\.|[:?]/,\n    punctuation: /[(){}\\[\\];,]/\n  }\n}\n"],"names":["psl"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,UAAiBA;AACjB,EAAAA,KAAI,cAAc;AAClB,EAAAA,KAAI,UAAU,CAAA;AACd,WAASA,KAAI,OAAO;AAClB,UAAM,UAAU,MAAM;AAAA,MACpB,SAAS;AAAA,QACP,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,QAAQ;AAAA,UACN,QAAQ;AAAA;;MAGZ,kBAAkB;AAAA,QAChB,SAAS;AAAA,QACT,OAAO;AAAA,QACP,QAAQ;AAAA;MAEV,SACE;AAAA,MACF,UACE;AAAA,MACF,SAAS;AAAA,MACT,UAAU;AAAA,MACV,SAAS;AAAA,QACP,SACE;AAAA,QACF,OAAO;AAAA;MAET,oBAAoB;AAAA,QAClB,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA;MAEV,UAAU;AAAA,MACV,QAAQ;AAAA,MACR,UAAU;AAAA,MACV,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/pug-DgeJ1i_u.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pug-DgeJ1i_u.js","sources":["../node_modules/refractor/lang/pug.js"],"sourcesContent":["'use strict'\n\nmodule.exports = pug\npug.displayName = 'pug'\npug.aliases = []\nfunction pug(Prism) {\n  ;(function (Prism) {\n    // TODO:\n    // - Add CSS highlighting inside <style> tags\n    // - Add support for multi-line code blocks\n    // - Add support for interpolation #{} and !{}\n    // - Add support for tag interpolation #[]\n    // - Add explicit support for plain text using |\n    // - Add support for markup embedded in plain text\n    Prism.languages.pug = {\n      // Multiline stuff should appear before the rest\n      // This handles both single-line and multi-line comments\n      comment: {\n        pattern: /(^([\\t ]*))\\/\\/.*(?:(?:\\r?\\n|\\r)\\2[\\t ].+)*/m,\n        lookbehind: true\n      },\n      // All the tag-related part is in lookbehind\n      // so that it can be highlighted by the \"tag\" pattern\n      'multiline-script': {\n        pattern:\n          /(^([\\t ]*)script\\b.*\\.[\\t ]*)(?:(?:\\r?\\n|\\r(?!\\n))(?:\\2[\\t ].+|\\s*?(?=\\r?\\n|\\r)))+/m,\n        lookbehind: true,\n        inside: Prism.languages.javascript\n      },\n      // See at the end of the file for known filters\n      filter: {\n        pattern:\n          /(^([\\t ]*)):.+(?:(?:\\r?\\n|\\r(?!\\n))(?:\\2[\\t ].+|\\s*?(?=\\r?\\n|\\r)))+/m,\n        lookbehind: true,\n        inside: {\n          'filter-name': {\n            pattern: /^:[\\w-]+/,\n            alias: 'variable'\n          },\n          text: /\\S[\\s\\S]*/\n        }\n      },\n      'multiline-plain-text': {\n        pattern:\n          /(^([\\t ]*)[\\w\\-#.]+\\.[\\t ]*)(?:(?:\\r?\\n|\\r(?!\\n))(?:\\2[\\t ].+|\\s*?(?=\\r?\\n|\\r)))+/m,\n        lookbehind: true\n      },\n      markup: {\n        pattern: /(^[\\t ]*)<.+/m,\n        lookbehind: true,\n        inside: Prism.languages.markup\n      },\n      doctype: {\n        pattern: /((?:^|\\n)[\\t ]*)doctype(?: .+)?/,\n        lookbehind: true\n      },\n      // This handle all conditional and loop keywords\n      'flow-control': {\n        pattern:\n          /(^[\\t ]*)(?:case|default|each|else|if|unless|when|while)\\b(?: .+)?/m,\n        lookbehind: true,\n        inside: {\n          each: {\n            pattern: /^each .+? in\\b/,\n            inside: {\n              keyword: /\\b(?:each|in)\\b/,\n              punctuation: /,/\n            }\n          },\n          branch: {\n            pattern: /^(?:case|default|else|if|unless|when|while)\\b/,\n            alias: 'keyword'\n          },\n          rest: Prism.languages.javascript\n        }\n      },\n      keyword: {\n        pattern: /(^[\\t ]*)(?:append|block|extends|include|prepend)\\b.+/m,\n        lookbehind: true\n      },\n      mixin: [\n        // Declaration\n        {\n          pattern: /(^[\\t ]*)mixin .+/m,\n          lookbehind: true,\n          inside: {\n            keyword: /^mixin/,\n            function: /\\w+(?=\\s*\\(|\\s*$)/,\n            punctuation: /[(),.]/\n          }\n        }, // Usage\n        {\n          pattern: /(^[\\t ]*)\\+.+/m,\n          lookbehind: true,\n          inside: {\n            name: {\n              pattern: /^\\+\\w+/,\n              alias: 'function'\n            },\n            rest: Prism.languages.javascript\n          }\n        }\n      ],\n      script: {\n        pattern: /(^[\\t ]*script(?:(?:&[^(]+)?\\([^)]+\\))*[\\t ]).+/m,\n        lookbehind: true,\n        inside: Prism.languages.javascript\n      },\n      'plain-text': {\n        pattern:\n          /(^[\\t ]*(?!-)[\\w\\-#.]*[\\w\\-](?:(?:&[^(]+)?\\([^)]+\\))*\\/?[\\t ]).+/m,\n        lookbehind: true\n      },\n      tag: {\n        pattern: /(^[\\t ]*)(?!-)[\\w\\-#.]*[\\w\\-](?:(?:&[^(]+)?\\([^)]+\\))*\\/?:?/m,\n        lookbehind: true,\n        inside: {\n          attributes: [\n            {\n              pattern: /&[^(]+\\([^)]+\\)/,\n              inside: Prism.languages.javascript\n            },\n            {\n              pattern: /\\([^)]+\\)/,\n              inside: {\n                'attr-value': {\n                  pattern: /(=\\s*(?!\\s))(?:\\{[^}]*\\}|[^,)\\r\\n]+)/,\n                  lookbehind: true,\n                  inside: Prism.languages.javascript\n                },\n                'attr-name': /[\\w-]+(?=\\s*!?=|\\s*[,)])/,\n                punctuation: /[!=(),]+/\n              }\n            }\n          ],\n          punctuation: /:/,\n          'attr-id': /#[\\w\\-]+/,\n          'attr-class': /\\.[\\w\\-]+/\n        }\n      },\n      code: [\n        {\n          pattern: /(^[\\t ]*(?:-|!?=)).+/m,\n          lookbehind: true,\n          inside: Prism.languages.javascript\n        }\n      ],\n      punctuation: /[.\\-!=|]+/\n    }\n    var filter_pattern =\n      /(^([\\t ]*)):<filter_name>(?:(?:\\r?\\n|\\r(?!\\n))(?:\\2[\\t ].+|\\s*?(?=\\r?\\n|\\r)))+/\n        .source // Non exhaustive list of available filters and associated languages\n    var filters = [\n      {\n        filter: 'atpl',\n        language: 'twig'\n      },\n      {\n        filter: 'coffee',\n        language: 'coffeescript'\n      },\n      'ejs',\n      'handlebars',\n      'less',\n      'livescript',\n      'markdown',\n      {\n        filter: 'sass',\n        language: 'scss'\n      },\n      'stylus'\n    ]\n    var all_filters = {}\n    for (var i = 0, l = filters.length; i < l; i++) {\n      var filter = filters[i]\n      filter =\n        typeof filter === 'string'\n          ? {\n              filter: filter,\n              language: filter\n            }\n          : filter\n      if (Prism.languages[filter.language]) {\n        all_filters['filter-' + filter.filter] = {\n          pattern: RegExp(\n            filter_pattern.replace('<filter_name>', function () {\n              return filter.filter\n            }),\n            'm'\n          ),\n          lookbehind: true,\n          inside: {\n            'filter-name': {\n              pattern: /^:[\\w-]+/,\n              alias: 'variable'\n            },\n            text: {\n              pattern: /\\S[\\s\\S]*/,\n              alias: [filter.language, 'language-' + filter.language],\n              inside: Prism.languages[filter.language]\n            }\n          }\n        }\n      }\n    }\n    Prism.languages.insertBefore('pug', 'filter', all_filters)\n  })(Prism)\n}\n"],"names":["pug","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,UAAiBA;AACjB,EAAAA,KAAI,cAAc;AAClB,EAAAA,KAAI,UAAU,CAAA;AACd,WAASA,KAAI,OAAO;AACjB,KAAC,SAAUC,QAAO;AAQjB,MAAAA,OAAM,UAAU,MAAM;AAAA;AAAA;AAAA,QAGpB,SAAS;AAAA,UACP,SAAS;AAAA,UACT,YAAY;AAAA;;;QAId,oBAAoB;AAAA,UAClB,SACE;AAAA,UACF,YAAY;AAAA,UACZ,QAAQA,OAAM,UAAU;AAAA;;QAG1B,QAAQ;AAAA,UACN,SACE;AAAA,UACF,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN,eAAe;AAAA,cACb,SAAS;AAAA,cACT,OAAO;AAAA;YAET,MAAM;AAAA;;QAGV,wBAAwB;AAAA,UACtB,SACE;AAAA,UACF,YAAY;AAAA;QAEd,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQA,OAAM,UAAU;AAAA;QAE1B,SAAS;AAAA,UACP,SAAS;AAAA,UACT,YAAY;AAAA;;QAGd,gBAAgB;AAAA,UACd,SACE;AAAA,UACF,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN,MAAM;AAAA,cACJ,SAAS;AAAA,cACT,QAAQ;AAAA,gBACN,SAAS;AAAA,gBACT,aAAa;AAAA;;YAGjB,QAAQ;AAAA,cACN,SAAS;AAAA,cACT,OAAO;AAAA;YAET,MAAMA,OAAM,UAAU;AAAA;;QAG1B,SAAS;AAAA,UACP,SAAS;AAAA,UACT,YAAY;AAAA;QAEd,OAAO;AAAA;AAAA,UAEL;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,SAAS;AAAA,cACT,UAAU;AAAA,cACV,aAAa;AAAA;;;UAGjB;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,MAAM;AAAA,gBACJ,SAAS;AAAA,gBACT,OAAO;AAAA;cAET,MAAMA,OAAM,UAAU;AAAA;;;QAI5B,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQA,OAAM,UAAU;AAAA;QAE1B,cAAc;AAAA,UACZ,SACE;AAAA,UACF,YAAY;AAAA;QAEd,KAAK;AAAA,UACH,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN,YAAY;AAAA,cACV;AAAA,gBACE,SAAS;AAAA,gBACT,QAAQA,OAAM,UAAU;AAAA;cAE1B;AAAA,gBACE,SAAS;AAAA,gBACT,QAAQ;AAAA,kBACN,cAAc;AAAA,oBACZ,SAAS;AAAA,oBACT,YAAY;AAAA,oBACZ,QAAQA,OAAM,UAAU;AAAA;kBAE1B,aAAa;AAAA,kBACb,aAAa;AAAA;;;YAInB,aAAa;AAAA,YACb,WAAW;AAAA,YACX,cAAc;AAAA;;QAGlB,MAAM;AAAA,UACJ;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,QAAQA,OAAM,UAAU;AAAA;;QAG5B,aAAa;AAAA;AAEf,UAAI,iBACF,iFACG;AACL,UAAI,UAAU;AAAA,QACZ;AAAA,UACE,QAAQ;AAAA,UACR,UAAU;AAAA;QAEZ;AAAA,UACE,QAAQ;AAAA,UACR,UAAU;AAAA;QAEZ;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,UACE,QAAQ;AAAA,UACR,UAAU;AAAA;QAEZ;AAAA;AAEF,UAAI,cAAc,CAAA;AAClB,eAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,IAAI,GAAG,KAAK;AAC9C,YAAI,SAAS,QAAQ,CAAC;AACtB,iBACE,OAAO,WAAW,WACd;AAAA,UACE;AAAA,UACA,UAAU;AAAA,YAEZ;AACN,YAAIA,OAAM,UAAU,OAAO,QAAQ,GAAG;AACpC,sBAAY,YAAY,OAAO,MAAM,IAAI;AAAA,YACvC,SAAS;AAAA,cACP,eAAe,QAAQ,iBAAiB,WAAY;AAClD,uBAAO,OAAO;AAAA,cAC5B,CAAa;AAAA,cACD;AAAA;YAEF,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,eAAe;AAAA,gBACb,SAAS;AAAA,gBACT,OAAO;AAAA;cAET,MAAM;AAAA,gBACJ,SAAS;AAAA,gBACT,OAAO,CAAC,OAAO,UAAU,cAAc,OAAO,QAAQ;AAAA,gBACtD,QAAQA,OAAM,UAAU,OAAO,QAAQ;AAAA;;;QAIrD;AAAA,MACA;AACI,MAAAA,OAAM,UAAU,aAAa,OAAO,UAAU,WAAW;AAAA,IAC7D,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/puppet-BX43JqCr.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"puppet-BX43JqCr.js","sources":["../node_modules/refractor/lang/puppet.js"],"sourcesContent":["'use strict'\n\nmodule.exports = puppet\npuppet.displayName = 'puppet'\npuppet.aliases = []\nfunction puppet(Prism) {\n  ;(function (Prism) {\n    Prism.languages.puppet = {\n      heredoc: [\n        // Matches the content of a quoted heredoc string (subject to interpolation)\n        {\n          pattern:\n            /(@\\(\"([^\"\\r\\n\\/):]+)\"(?:\\/[nrts$uL]*)?\\).*(?:\\r?\\n|\\r))(?:.*(?:\\r?\\n|\\r(?!\\n)))*?[ \\t]*(?:\\|[ \\t]*)?(?:-[ \\t]*)?\\2/,\n          lookbehind: true,\n          alias: 'string',\n          inside: {\n            // Matches the end tag\n            punctuation: /(?=\\S).*\\S(?= *$)/ // See interpolation below\n          }\n        }, // Matches the content of an unquoted heredoc string (no interpolation)\n        {\n          pattern:\n            /(@\\(([^\"\\r\\n\\/):]+)(?:\\/[nrts$uL]*)?\\).*(?:\\r?\\n|\\r))(?:.*(?:\\r?\\n|\\r(?!\\n)))*?[ \\t]*(?:\\|[ \\t]*)?(?:-[ \\t]*)?\\2/,\n          lookbehind: true,\n          greedy: true,\n          alias: 'string',\n          inside: {\n            // Matches the end tag\n            punctuation: /(?=\\S).*\\S(?= *$)/\n          }\n        }, // Matches the start tag of heredoc strings\n        {\n          pattern: /@\\(\"?(?:[^\"\\r\\n\\/):]+)\"?(?:\\/[nrts$uL]*)?\\)/,\n          alias: 'string',\n          inside: {\n            punctuation: {\n              pattern: /(\\().+?(?=\\))/,\n              lookbehind: true\n            }\n          }\n        }\n      ],\n      'multiline-comment': {\n        pattern: /(^|[^\\\\])\\/\\*[\\s\\S]*?\\*\\//,\n        lookbehind: true,\n        greedy: true,\n        alias: 'comment'\n      },\n      regex: {\n        // Must be prefixed with the keyword \"node\" or a non-word char\n        pattern:\n          /((?:\\bnode\\s+|[~=\\(\\[\\{,]\\s*|[=+]>\\s*|^\\s*))\\/(?:[^\\/\\\\]|\\\\[\\s\\S])+\\/(?:[imx]+\\b|\\B)/,\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          // Extended regexes must have the x flag. They can contain single-line comments.\n          'extended-regex': {\n            pattern: /^\\/(?:[^\\/\\\\]|\\\\[\\s\\S])+\\/[im]*x[im]*$/,\n            inside: {\n              comment: /#.*/\n            }\n          }\n        }\n      },\n      comment: {\n        pattern: /(^|[^\\\\])#.*/,\n        lookbehind: true,\n        greedy: true\n      },\n      string: {\n        // Allow for one nested level of double quotes inside interpolation\n        pattern:\n          /([\"'])(?:\\$\\{(?:[^'\"}]|([\"'])(?:(?!\\2)[^\\\\]|\\\\[\\s\\S])*\\2)+\\}|\\$(?!\\{)|(?!\\1)[^\\\\$]|\\\\[\\s\\S])*\\1/,\n        greedy: true,\n        inside: {\n          'double-quoted': {\n            pattern: /^\"[\\s\\S]*\"$/,\n            inside: {\n              // See interpolation below\n            }\n          }\n        }\n      },\n      variable: {\n        pattern: /\\$(?:::)?\\w+(?:::\\w+)*/,\n        inside: {\n          punctuation: /::/\n        }\n      },\n      'attr-name': /(?:\\b\\w+|\\*)(?=\\s*=>)/,\n      function: [\n        {\n          pattern: /(\\.)(?!\\d)\\w+/,\n          lookbehind: true\n        },\n        /\\b(?:contain|debug|err|fail|include|info|notice|realize|require|tag|warning)\\b|\\b(?!\\d)\\w+(?=\\()/\n      ],\n      number: /\\b(?:0x[a-f\\d]+|\\d+(?:\\.\\d+)?(?:e-?\\d+)?)\\b/i,\n      boolean: /\\b(?:false|true)\\b/,\n      // Includes words reserved for future use\n      keyword:\n        /\\b(?:application|attr|case|class|consumes|default|define|else|elsif|function|if|import|inherits|node|private|produces|type|undef|unless)\\b/,\n      datatype: {\n        pattern:\n          /\\b(?:Any|Array|Boolean|Callable|Catalogentry|Class|Collection|Data|Default|Enum|Float|Hash|Integer|NotUndef|Numeric|Optional|Pattern|Regexp|Resource|Runtime|Scalar|String|Struct|Tuple|Type|Undef|Variant)\\b/,\n        alias: 'symbol'\n      },\n      operator:\n        /=[=~>]?|![=~]?|<(?:<\\|?|[=~|-])?|>[>=]?|->?|~>|\\|>?>?|[*\\/%+?]|\\b(?:and|in|or)\\b/,\n      punctuation: /[\\[\\]{}().,;]|:+/\n    }\n    var interpolation = [\n      {\n        // Allow for one nested level of braces inside interpolation\n        pattern:\n          /(^|[^\\\\])\\$\\{(?:[^'\"{}]|\\{[^}]*\\}|([\"'])(?:(?!\\2)[^\\\\]|\\\\[\\s\\S])*\\2)+\\}/,\n        lookbehind: true,\n        inside: {\n          'short-variable': {\n            // Negative look-ahead prevent wrong highlighting of functions\n            pattern: /(^\\$\\{)(?!\\w+\\()(?:::)?\\w+(?:::\\w+)*/,\n            lookbehind: true,\n            alias: 'variable',\n            inside: {\n              punctuation: /::/\n            }\n          },\n          delimiter: {\n            pattern: /^\\$/,\n            alias: 'variable'\n          },\n          rest: Prism.languages.puppet\n        }\n      },\n      {\n        pattern: /(^|[^\\\\])\\$(?:::)?\\w+(?:::\\w+)*/,\n        lookbehind: true,\n        alias: 'variable',\n        inside: {\n          punctuation: /::/\n        }\n      }\n    ]\n    Prism.languages.puppet['heredoc'][0].inside.interpolation = interpolation\n    Prism.languages.puppet['string'].inside[\n      'double-quoted'\n    ].inside.interpolation = interpolation\n  })(Prism)\n}\n"],"names":["puppet","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAA;AACjB,WAASA,QAAO,OAAO;AACpB,KAAC,SAAUC,QAAO;AACjB,MAAAA,OAAM,UAAU,SAAS;AAAA,QACvB,SAAS;AAAA;AAAA,UAEP;AAAA,YACE,SACE;AAAA,YACF,YAAY;AAAA,YACZ,OAAO;AAAA,YACP,QAAQ;AAAA;AAAA,cAEN,aAAa;AAAA;AAAA;;;UAGjB;AAAA,YACE,SACE;AAAA,YACF,YAAY;AAAA,YACZ,QAAQ;AAAA,YACR,OAAO;AAAA,YACP,QAAQ;AAAA;AAAA,cAEN,aAAa;AAAA;;;UAGjB;AAAA,YACE,SAAS;AAAA,YACT,OAAO;AAAA,YACP,QAAQ;AAAA,cACN,aAAa;AAAA,gBACX,SAAS;AAAA,gBACT,YAAY;AAAA;;;;QAKpB,qBAAqB;AAAA,UACnB,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA,UACR,OAAO;AAAA;QAET,OAAO;AAAA;AAAA,UAEL,SACE;AAAA,UACF,YAAY;AAAA,UACZ,QAAQ;AAAA,UACR,QAAQ;AAAA;AAAA,YAEN,kBAAkB;AAAA,cAChB,SAAS;AAAA,cACT,QAAQ;AAAA,gBACN,SAAS;AAAA;;;;QAKjB,SAAS;AAAA,UACP,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA;QAEV,QAAQ;AAAA;AAAA,UAEN,SACE;AAAA,UACF,QAAQ;AAAA,UACR,QAAQ;AAAA,YACN,iBAAiB;AAAA,cACf,SAAS;AAAA,cACT,QAAQ;AAAA;AAAA;;;;QAMd,UAAU;AAAA,UACR,SAAS;AAAA,UACT,QAAQ;AAAA,YACN,aAAa;AAAA;;QAGjB,aAAa;AAAA,QACb,UAAU;AAAA,UACR;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA;UAEd;AAAA;QAEF,QAAQ;AAAA,QACR,SAAS;AAAA;AAAA,QAET,SACE;AAAA,QACF,UAAU;AAAA,UACR,SACE;AAAA,UACF,OAAO;AAAA;QAET,UACE;AAAA,QACF,aAAa;AAAA;AAEf,UAAI,gBAAgB;AAAA,QAClB;AAAA;AAAA,UAEE,SACE;AAAA,UACF,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN,kBAAkB;AAAA;AAAA,cAEhB,SAAS;AAAA,cACT,YAAY;AAAA,cACZ,OAAO;AAAA,cACP,QAAQ;AAAA,gBACN,aAAa;AAAA;;YAGjB,WAAW;AAAA,cACT,SAAS;AAAA,cACT,OAAO;AAAA;YAET,MAAMA,OAAM,UAAU;AAAA;;QAG1B;AAAA,UACE,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,OAAO;AAAA,UACP,QAAQ;AAAA,YACN,aAAa;AAAA;;;AAInB,MAAAA,OAAM,UAAU,OAAO,SAAS,EAAE,CAAC,EAAE,OAAO,gBAAgB;AAC5D,MAAAA,OAAM,UAAU,OAAO,QAAQ,EAAE,OAC/B,eACN,EAAM,OAAO,gBAAgB;AAAA,IAC7B,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/pure-BksDdMQ8.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pure-BksDdMQ8.js","sources":["../node_modules/refractor/lang/pure.js"],"sourcesContent":["'use strict'\n\nmodule.exports = pure\npure.displayName = 'pure'\npure.aliases = []\nfunction pure(Prism) {\n  ;(function (Prism) {\n    // https://agraef.github.io/pure-docs/pure.html#lexical-matters\n    Prism.languages.pure = {\n      comment: [\n        {\n          pattern: /(^|[^\\\\])\\/\\*[\\s\\S]*?\\*\\//,\n          lookbehind: true\n        },\n        {\n          pattern: /(^|[^\\\\:])\\/\\/.*/,\n          lookbehind: true\n        },\n        /#!.+/\n      ],\n      'inline-lang': {\n        pattern: /%<[\\s\\S]+?%>/,\n        greedy: true,\n        inside: {\n          lang: {\n            pattern: /(^%< *)-\\*-.+?-\\*-/,\n            lookbehind: true,\n            alias: 'comment'\n          },\n          delimiter: {\n            pattern: /^%<.*|%>$/,\n            alias: 'punctuation'\n          }\n        }\n      },\n      string: {\n        pattern: /\"(?:\\\\.|[^\"\\\\\\r\\n])*\"/,\n        greedy: true\n      },\n      number: {\n        // The look-behind prevents wrong highlighting of the .. operator\n        pattern:\n          /((?:\\.\\.)?)(?:\\b(?:inf|nan)\\b|\\b0x[\\da-f]+|(?:\\b(?:0b)?\\d+(?:\\.\\d+)?|\\B\\.\\d+)(?:e[+-]?\\d+)?L?)/i,\n        lookbehind: true\n      },\n      keyword:\n        /\\b(?:NULL|ans|break|bt|case|catch|cd|clear|const|def|del|dump|else|end|exit|extern|false|force|help|if|infix[lr]?|interface|let|ls|mem|namespace|nonfix|of|otherwise|outfix|override|postfix|prefix|private|public|pwd|quit|run|save|show|stats|then|throw|trace|true|type|underride|using|when|with)\\b/,\n      function:\n        /\\b(?:abs|add_(?:addr|constdef|(?:fundef|interface|macdef|typedef)(?:_at)?|vardef)|all|any|applp?|arity|bigintp?|blob(?:_crc|_size|p)?|boolp?|byte_c?string(?:_pointer)?|byte_(?:matrix|pointer)|calloc|cat|catmap|ceil|char[ps]?|check_ptrtag|chr|clear_sentry|clearsym|closurep?|cmatrixp?|cols?|colcat(?:map)?|colmap|colrev|colvector(?:p|seq)?|complex(?:_float_(?:matrix|pointer)|_matrix(?:_view)?|_pointer|p)?|conj|cookedp?|cst|cstring(?:_(?:dup|list|vector))?|curry3?|cyclen?|del_(?:constdef|fundef|interface|macdef|typedef|vardef)|delete|diag(?:mat)?|dim|dmatrixp?|do|double(?:_matrix(?:_view)?|_pointer|p)?|dowith3?|drop|dropwhile|eval(?:cmd)?|exactp|filter|fix|fixity|flip|float(?:_matrix|_pointer)|floor|fold[lr]1?|frac|free|funp?|functionp?|gcd|get(?:_(?:byte|constdef|double|float|fundef|int(?:64)?|interface(?:_typedef)?|long|macdef|pointer|ptrtag|sentry|short|string|typedef|vardef))?|globsym|hash|head|id|im|imatrixp?|index|inexactp|infp|init|insert|int(?:_matrix(?:_view)?|_pointer|p)?|int64_(?:matrix|pointer)|integerp?|iteraten?|iterwhile|join|keys?|lambdap?|last(?:err(?:pos)?)?|lcd|list[2p]?|listmap|make_ptrtag|malloc|map|matcat|matrixp?|max|member|min|nanp|nargs|nmatrixp?|null|numberp?|ord|pack(?:ed)?|pointer(?:_cast|_tag|_type|p)?|pow|pred|ptrtag|put(?:_(?:byte|double|float|int(?:64)?|long|pointer|short|string))?|rationalp?|re|realp?|realloc|recordp?|redim|reduce(?:_with)?|refp?|repeatn?|reverse|rlistp?|round|rows?|rowcat(?:map)?|rowmap|rowrev|rowvector(?:p|seq)?|same|scan[lr]1?|sentry|sgn|short_(?:matrix|pointer)|slice|smatrixp?|sort|split|str|strcat|stream|stride|string(?:_(?:dup|list|vector)|p)?|subdiag(?:mat)?|submat|subseq2?|substr|succ|supdiag(?:mat)?|symbolp?|tail|take|takewhile|thunkp?|transpose|trunc|tuplep?|typep|ubyte|uint(?:64)?|ulong|uncurry3?|unref|unzip3?|update|ushort|vals?|varp?|vector(?:p|seq)?|void|zip3?|zipwith3?)\\b/,\n      special: {\n        pattern: /\\b__[a-z]+__\\b/i,\n        alias: 'builtin'\n      },\n      // Any combination of operator chars can be an operator\n      // eslint-disable-next-line no-misleading-character-class\n      operator:\n        /(?:[!\"#$%&'*+,\\-.\\/:<=>?@\\\\^`|~\\u00a1-\\u00bf\\u00d7-\\u00f7\\u20d0-\\u2bff]|\\b_+\\b)+|\\b(?:and|div|mod|not|or)\\b/,\n      // FIXME: How can we prevent | and , to be highlighted as operator when they are used alone?\n      punctuation: /[(){}\\[\\];,|]/\n    }\n    var inlineLanguages = [\n      'c',\n      {\n        lang: 'c++',\n        alias: 'cpp'\n      },\n      'fortran'\n    ]\n    var inlineLanguageRe = /%< *-\\*- *<lang>\\d* *-\\*-[\\s\\S]+?%>/.source\n    inlineLanguages.forEach(function (lang) {\n      var alias = lang\n      if (typeof lang !== 'string') {\n        alias = lang.alias\n        lang = lang.lang\n      }\n      if (Prism.languages[alias]) {\n        var o = {}\n        o['inline-lang-' + alias] = {\n          pattern: RegExp(\n            inlineLanguageRe.replace(\n              '<lang>',\n              lang.replace(/([.+*?\\/\\\\(){}\\[\\]])/g, '\\\\$1')\n            ),\n            'i'\n          ),\n          inside: Prism.util.clone(Prism.languages.pure['inline-lang'].inside)\n        }\n        o['inline-lang-' + alias].inside.rest = Prism.util.clone(\n          Prism.languages[alias]\n        )\n        Prism.languages.insertBefore('pure', 'inline-lang', o)\n      }\n    }) // C is the default inline language\n    if (Prism.languages.c) {\n      Prism.languages.pure['inline-lang'].inside.rest = Prism.util.clone(\n        Prism.languages.c\n      )\n    }\n  })(Prism)\n}\n"],"names":["pure","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AAClB,KAAC,SAAUC,QAAO;AAEjB,MAAAA,OAAM,UAAU,OAAO;AAAA,QACrB,SAAS;AAAA,UACP;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA;UAEd;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA;UAEd;AAAA;QAEF,eAAe;AAAA,UACb,SAAS;AAAA,UACT,QAAQ;AAAA,UACR,QAAQ;AAAA,YACN,MAAM;AAAA,cACJ,SAAS;AAAA,cACT,YAAY;AAAA,cACZ,OAAO;AAAA;YAET,WAAW;AAAA,cACT,SAAS;AAAA,cACT,OAAO;AAAA;;;QAIb,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV,QAAQ;AAAA;AAAA,UAEN,SACE;AAAA,UACF,YAAY;AAAA;QAEd,SACE;AAAA,QACF,UACE;AAAA,QACF,SAAS;AAAA,UACP,SAAS;AAAA,UACT,OAAO;AAAA;;;QAIT,UACE;AAAA;AAAA,QAEF,aAAa;AAAA;AAEf,UAAI,kBAAkB;AAAA,QACpB;AAAA,QACA;AAAA,UACE,MAAM;AAAA,UACN,OAAO;AAAA;QAET;AAAA;AAEF,UAAI,mBAAmB,sCAAsC;AAC7D,sBAAgB,QAAQ,SAAU,MAAM;AACtC,YAAI,QAAQ;AACZ,YAAI,OAAO,SAAS,UAAU;AAC5B,kBAAQ,KAAK;AACb,iBAAO,KAAK;AAAA,QACpB;AACM,YAAIA,OAAM,UAAU,KAAK,GAAG;AAC1B,cAAI,IAAI,CAAA;AACR,YAAE,iBAAiB,KAAK,IAAI;AAAA,YAC1B,SAAS;AAAA,cACP,iBAAiB;AAAA,gBACf;AAAA,gBACA,KAAK,QAAQ,yBAAyB,MAAM;AAAA;cAE9C;AAAA;YAEF,QAAQA,OAAM,KAAK,MAAMA,OAAM,UAAU,KAAK,aAAa,EAAE,MAAM;AAAA;AAErE,YAAE,iBAAiB,KAAK,EAAE,OAAO,OAAOA,OAAM,KAAK;AAAA,YACjDA,OAAM,UAAU,KAAK;AAAA;AAEvB,UAAAA,OAAM,UAAU,aAAa,QAAQ,eAAe,CAAC;AAAA,QAC7D;AAAA,MACA,CAAK;AACD,UAAIA,OAAM,UAAU,GAAG;AACrB,QAAAA,OAAM,UAAU,KAAK,aAAa,EAAE,OAAO,OAAOA,OAAM,KAAK;AAAA,UAC3DA,OAAM,UAAU;AAAA;MAExB;AAAA,IACA,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/purebasic-DJv8fxSc.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"purebasic-DJv8fxSc.js","sources":["../node_modules/refractor/lang/purebasic.js"],"sourcesContent":["'use strict'\n\nmodule.exports = purebasic\npurebasic.displayName = 'purebasic'\npurebasic.aliases = []\nfunction purebasic(Prism) {\n  /*\nOriginal Code by Bas Groothedde\n!!MANY THANKS!! I never would have made this, regex and me will never be best friends ;)\n==> https://codepen.io/ImagineProgramming/details/JYydBy/\nslightly changed to pass all tests\n*/\n  // PureBasic support, steal stuff from ansi-c\n  Prism.languages.purebasic = Prism.languages.extend('clike', {\n    comment: /;.*/,\n    keyword:\n      /\\b(?:align|and|as|break|calldebugger|case|compilercase|compilerdefault|compilerelse|compilerelseif|compilerendif|compilerendselect|compilererror|compilerif|compilerselect|continue|data|datasection|debug|debuglevel|declare|declarec|declarecdll|declaredll|declaremodule|default|define|dim|disableasm|disabledebugger|disableexplicit|else|elseif|enableasm|enabledebugger|enableexplicit|end|enddatasection|enddeclaremodule|endenumeration|endif|endimport|endinterface|endmacro|endmodule|endprocedure|endselect|endstructure|endstructureunion|endwith|enumeration|extends|fakereturn|for|foreach|forever|global|gosub|goto|if|import|importc|includebinary|includefile|includepath|interface|macro|module|newlist|newmap|next|not|or|procedure|procedurec|procedurecdll|proceduredll|procedurereturn|protected|prototype|prototypec|read|redim|repeat|restore|return|runtime|select|shared|static|step|structure|structureunion|swap|threaded|to|until|wend|while|with|xincludefile|xor)\\b/i,\n    function: /\\b\\w+(?:\\.\\w+)?\\s*(?=\\()/,\n    number: /(?:\\$[\\da-f]+|\\b-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)(?:e[+-]?\\d+)?)\\b/i,\n    operator:\n      /(?:@\\*?|\\?|\\*)\\w+|-[>-]?|\\+\\+?|!=?|<<?=?|>>?=?|==?|&&?|\\|?\\||[~^%?*/@]/\n  })\n  Prism.languages.insertBefore('purebasic', 'keyword', {\n    tag: /#\\w+\\$?/,\n    asm: {\n      pattern: /(^[\\t ]*)!.*/m,\n      lookbehind: true,\n      alias: 'tag',\n      inside: {\n        comment: /;.*/,\n        string: {\n          pattern: /([\"'`])(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/,\n          greedy: true\n        },\n        // Anonymous label references, i.e.: jmp @b\n        'label-reference-anonymous': {\n          pattern: /(!\\s*j[a-z]+\\s+)@[fb]/i,\n          lookbehind: true,\n          alias: 'fasm-label'\n        },\n        // Named label reference, i.e.: jne label1\n        'label-reference-addressed': {\n          pattern: /(!\\s*j[a-z]+\\s+)[A-Z._?$@][\\w.?$@~#]*/i,\n          lookbehind: true,\n          alias: 'fasm-label'\n        },\n        keyword: [\n          /\\b(?:extern|global)\\b[^;\\r\\n]*/i,\n          /\\b(?:CPU|DEFAULT|FLOAT)\\b.*/\n        ],\n        function: {\n          pattern: /^([\\t ]*!\\s*)[\\da-z]+(?=\\s|$)/im,\n          lookbehind: true\n        },\n        'function-inline': {\n          pattern: /(:\\s*)[\\da-z]+(?=\\s)/i,\n          lookbehind: true,\n          alias: 'function'\n        },\n        label: {\n          pattern: /^([\\t ]*!\\s*)[A-Za-z._?$@][\\w.?$@~#]*(?=:)/m,\n          lookbehind: true,\n          alias: 'fasm-label'\n        },\n        register:\n          /\\b(?:st\\d|[xyz]mm\\d\\d?|[cdt]r\\d|r\\d\\d?[bwd]?|[er]?[abcd]x|[abcd][hl]|[er]?(?:bp|di|si|sp)|[cdefgs]s|mm\\d+)\\b/i,\n        number:\n          /(?:\\b|-|(?=\\$))(?:0[hx](?:[\\da-f]*\\.)?[\\da-f]+(?:p[+-]?\\d+)?|\\d[\\da-f]+[hx]|\\$\\d[\\da-f]*|0[oq][0-7]+|[0-7]+[oq]|0[by][01]+|[01]+[by]|0[dt]\\d+|(?:\\d+(?:\\.\\d+)?|\\.\\d+)(?:\\.?e[+-]?\\d+)?[dt]?)\\b/i,\n        operator: /[\\[\\]*+\\-/%<>=&|$!,.:]/\n      }\n    }\n  })\n  delete Prism.languages.purebasic['class-name']\n  delete Prism.languages.purebasic['boolean']\n  Prism.languages.pbfasm = Prism.languages['purebasic']\n}\n"],"names":["purebasic"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,gBAAiBA;AACjB,EAAAA,WAAU,cAAc;AACxB,EAAAA,WAAU,UAAU,CAAA;AACpB,WAASA,WAAU,OAAO;AAQxB,UAAM,UAAU,YAAY,MAAM,UAAU,OAAO,SAAS;AAAA,MAC1D,SAAS;AAAA,MACT,SACE;AAAA,MACF,UAAU;AAAA,MACV,QAAQ;AAAA,MACR,UACE;AAAA,IACN,CAAG;AACD,UAAM,UAAU,aAAa,aAAa,WAAW;AAAA,MACnD,KAAK;AAAA,MACL,KAAK;AAAA,QACH,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA,QACP,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,QAAQ;AAAA,YACN,SAAS;AAAA,YACT,QAAQ;AAAA;;UAGV,6BAA6B;AAAA,YAC3B,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,OAAO;AAAA;;UAGT,6BAA6B;AAAA,YAC3B,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,OAAO;AAAA;UAET,SAAS;AAAA,YACP;AAAA,YACA;AAAA;UAEF,UAAU;AAAA,YACR,SAAS;AAAA,YACT,YAAY;AAAA;UAEd,mBAAmB;AAAA,YACjB,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,OAAO;AAAA;UAET,OAAO;AAAA,YACL,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,OAAO;AAAA;UAET,UACE;AAAA,UACF,QACE;AAAA,UACF,UAAU;AAAA;;IAGlB,CAAG;AACD,WAAO,MAAM,UAAU,UAAU,YAAY;AAC7C,WAAO,MAAM,UAAU,UAAU,SAAS;AAC1C,UAAM,UAAU,SAAS,MAAM,UAAU,WAAW;AAAA,EACtD;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/purescript-Dg9Gz0Mn.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"purescript-Dg9Gz0Mn.js","sources":["../node_modules/refractor/lang/purescript.js"],"sourcesContent":["'use strict'\nvar refractorHaskell = require('./haskell.js')\nmodule.exports = purescript\npurescript.displayName = 'purescript'\npurescript.aliases = ['purs']\nfunction purescript(Prism) {\n  Prism.register(refractorHaskell)\n  Prism.languages.purescript = Prism.languages.extend('haskell', {\n    keyword:\n      /\\b(?:ado|case|class|data|derive|do|else|forall|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where)\\b|∀/,\n    'import-statement': {\n      // The imported or hidden names are not included in this import\n      // statement. This is because we want to highlight those exactly like\n      // we do for the names in the program.\n      pattern:\n        /(^[\\t ]*)import\\s+[A-Z][\\w']*(?:\\.[A-Z][\\w']*)*(?:\\s+as\\s+[A-Z][\\w']*(?:\\.[A-Z][\\w']*)*)?(?:\\s+hiding\\b)?/m,\n      lookbehind: true,\n      inside: {\n        keyword: /\\b(?:as|hiding|import)\\b/,\n        punctuation: /\\./\n      }\n    },\n    // These are builtin functions only. Constructors are highlighted later as a constant.\n    builtin:\n      /\\b(?:absurd|add|ap|append|apply|between|bind|bottom|clamp|compare|comparing|compose|conj|const|degree|discard|disj|div|eq|flap|flip|gcd|identity|ifM|join|lcm|liftA1|liftM1|map|max|mempty|min|mod|mul|negate|not|notEq|one|otherwise|recip|show|sub|top|unit|unless|unlessM|void|when|whenM|zero)\\b/,\n    operator: [\n      // Infix operators\n      Prism.languages.haskell.operator[0], // ASCII operators\n      Prism.languages.haskell.operator[2], // All UTF16 Unicode operator symbols\n      // This regex is equivalent to /(?=[\\x80-\\uFFFF])[\\p{gc=Math_Symbol}\\p{gc=Currency_Symbol}\\p{Modifier_Symbol}\\p{Other_Symbol}]/u\n      // See https://github.com/PrismJS/prism/issues/3006 for more details.\n      /[\\xa2-\\xa6\\xa8\\xa9\\xac\\xae-\\xb1\\xb4\\xb8\\xd7\\xf7\\u02c2-\\u02c5\\u02d2-\\u02df\\u02e5-\\u02eb\\u02ed\\u02ef-\\u02ff\\u0375\\u0384\\u0385\\u03f6\\u0482\\u058d-\\u058f\\u0606-\\u0608\\u060b\\u060e\\u060f\\u06de\\u06e9\\u06fd\\u06fe\\u07f6\\u07fe\\u07ff\\u09f2\\u09f3\\u09fa\\u09fb\\u0af1\\u0b70\\u0bf3-\\u0bfa\\u0c7f\\u0d4f\\u0d79\\u0e3f\\u0f01-\\u0f03\\u0f13\\u0f15-\\u0f17\\u0f1a-\\u0f1f\\u0f34\\u0f36\\u0f38\\u0fbe-\\u0fc5\\u0fc7-\\u0fcc\\u0fce\\u0fcf\\u0fd5-\\u0fd8\\u109e\\u109f\\u1390-\\u1399\\u166d\\u17db\\u1940\\u19de-\\u19ff\\u1b61-\\u1b6a\\u1b74-\\u1b7c\\u1fbd\\u1fbf-\\u1fc1\\u1fcd-\\u1fcf\\u1fdd-\\u1fdf\\u1fed-\\u1fef\\u1ffd\\u1ffe\\u2044\\u2052\\u207a-\\u207c\\u208a-\\u208c\\u20a0-\\u20bf\\u2100\\u2101\\u2103-\\u2106\\u2108\\u2109\\u2114\\u2116-\\u2118\\u211e-\\u2123\\u2125\\u2127\\u2129\\u212e\\u213a\\u213b\\u2140-\\u2144\\u214a-\\u214d\\u214f\\u218a\\u218b\\u2190-\\u2307\\u230c-\\u2328\\u232b-\\u2426\\u2440-\\u244a\\u249c-\\u24e9\\u2500-\\u2767\\u2794-\\u27c4\\u27c7-\\u27e5\\u27f0-\\u2982\\u2999-\\u29d7\\u29dc-\\u29fb\\u29fe-\\u2b73\\u2b76-\\u2b95\\u2b97-\\u2bff\\u2ce5-\\u2cea\\u2e50\\u2e51\\u2e80-\\u2e99\\u2e9b-\\u2ef3\\u2f00-\\u2fd5\\u2ff0-\\u2ffb\\u3004\\u3012\\u3013\\u3020\\u3036\\u3037\\u303e\\u303f\\u309b\\u309c\\u3190\\u3191\\u3196-\\u319f\\u31c0-\\u31e3\\u3200-\\u321e\\u322a-\\u3247\\u3250\\u3260-\\u327f\\u328a-\\u32b0\\u32c0-\\u33ff\\u4dc0-\\u4dff\\ua490-\\ua4c6\\ua700-\\ua716\\ua720\\ua721\\ua789\\ua78a\\ua828-\\ua82b\\ua836-\\ua839\\uaa77-\\uaa79\\uab5b\\uab6a\\uab6b\\ufb29\\ufbb2-\\ufbc1\\ufdfc\\ufdfd\\ufe62\\ufe64-\\ufe66\\ufe69\\uff04\\uff0b\\uff1c-\\uff1e\\uff3e\\uff40\\uff5c\\uff5e\\uffe0-\\uffe6\\uffe8-\\uffee\\ufffc\\ufffd]/\n    ]\n  })\n  Prism.languages.purs = Prism.languages.purescript\n}\n"],"names":["require$$0","purescript"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,mBAAmBA,eAAA;AACvB,iBAAiBC;AACjB,EAAAA,YAAW,cAAc;AACzB,EAAAA,YAAW,UAAU,CAAC,MAAM;AAC5B,WAASA,YAAW,OAAO;AACzB,UAAM,SAAS,gBAAgB;AAC/B,UAAM,UAAU,aAAa,MAAM,UAAU,OAAO,WAAW;AAAA,MAC7D,SACE;AAAA,MACF,oBAAoB;AAAA;AAAA;AAAA;AAAA,QAIlB,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,aAAa;AAAA;;;MAIjB,SACE;AAAA,MACF,UAAU;AAAA;AAAA,QAER,MAAM,UAAU,QAAQ,SAAS,CAAC;AAAA;AAAA,QAClC,MAAM,UAAU,QAAQ,SAAS,CAAC;AAAA;AAAA;AAAA;AAAA,QAGlC;AAAA;IAEN,CAAG;AACD,UAAM,UAAU,OAAO,MAAM,UAAU;AAAA,EACzC;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/python-Vb9NO3vE.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"python-Vb9NO3vE.js","sources":["../node_modules/refractor/lang/python.js"],"sourcesContent":["'use strict'\n\nmodule.exports = python\npython.displayName = 'python'\npython.aliases = ['py']\nfunction python(Prism) {\n  Prism.languages.python = {\n    comment: {\n      pattern: /(^|[^\\\\])#.*/,\n      lookbehind: true,\n      greedy: true\n    },\n    'string-interpolation': {\n      pattern:\n        /(?:f|fr|rf)(?:(\"\"\"|''')[\\s\\S]*?\\1|(\"|')(?:\\\\.|(?!\\2)[^\\\\\\r\\n])*\\2)/i,\n      greedy: true,\n      inside: {\n        interpolation: {\n          // \"{\" <expression> <optional \"!s\", \"!r\", or \"!a\"> <optional \":\" format specifier> \"}\"\n          pattern:\n            /((?:^|[^{])(?:\\{\\{)*)\\{(?!\\{)(?:[^{}]|\\{(?!\\{)(?:[^{}]|\\{(?!\\{)(?:[^{}])+\\})+\\})+\\}/,\n          lookbehind: true,\n          inside: {\n            'format-spec': {\n              pattern: /(:)[^:(){}]+(?=\\}$)/,\n              lookbehind: true\n            },\n            'conversion-option': {\n              pattern: /![sra](?=[:}]$)/,\n              alias: 'punctuation'\n            },\n            rest: null\n          }\n        },\n        string: /[\\s\\S]+/\n      }\n    },\n    'triple-quoted-string': {\n      pattern: /(?:[rub]|br|rb)?(\"\"\"|''')[\\s\\S]*?\\1/i,\n      greedy: true,\n      alias: 'string'\n    },\n    string: {\n      pattern: /(?:[rub]|br|rb)?(\"|')(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/i,\n      greedy: true\n    },\n    function: {\n      pattern: /((?:^|\\s)def[ \\t]+)[a-zA-Z_]\\w*(?=\\s*\\()/g,\n      lookbehind: true\n    },\n    'class-name': {\n      pattern: /(\\bclass\\s+)\\w+/i,\n      lookbehind: true\n    },\n    decorator: {\n      pattern: /(^[\\t ]*)@\\w+(?:\\.\\w+)*/m,\n      lookbehind: true,\n      alias: ['annotation', 'punctuation'],\n      inside: {\n        punctuation: /\\./\n      }\n    },\n    keyword:\n      /\\b(?:_(?=\\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\\b/,\n    builtin:\n      /\\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\\b/,\n    boolean: /\\b(?:False|None|True)\\b/,\n    number:\n      /\\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\\b|(?:\\b\\d+(?:_\\d+)*(?:\\.(?:\\d+(?:_\\d+)*)?)?|\\B\\.\\d+(?:_\\d+)*)(?:e[+-]?\\d+(?:_\\d+)*)?j?(?!\\w)/i,\n    operator: /[-+%=]=?|!=|:=|\\*\\*?=?|\\/\\/?=?|<[<=>]?|>[=>]?|[&|^~]/,\n    punctuation: /[{}[\\];(),.:]/\n  }\n  Prism.languages.python['string-interpolation'].inside[\n    'interpolation'\n  ].inside.rest = Prism.languages.python\n  Prism.languages.py = Prism.languages.python\n}\n"],"names":["python"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAC,IAAI;AACtB,WAASA,QAAO,OAAO;AACrB,UAAM,UAAU,SAAS;AAAA,MACvB,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ;AAAA;MAEV,wBAAwB;AAAA,QACtB,SACE;AAAA,QACF,QAAQ;AAAA,QACR,QAAQ;AAAA,UACN,eAAe;AAAA;AAAA,YAEb,SACE;AAAA,YACF,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,eAAe;AAAA,gBACb,SAAS;AAAA,gBACT,YAAY;AAAA;cAEd,qBAAqB;AAAA,gBACnB,SAAS;AAAA,gBACT,OAAO;AAAA;cAET,MAAM;AAAA;;UAGV,QAAQ;AAAA;;MAGZ,wBAAwB;AAAA,QACtB,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,OAAO;AAAA;MAET,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,UAAU;AAAA,QACR,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,cAAc;AAAA,QACZ,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,WAAW;AAAA,QACT,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO,CAAC,cAAc,aAAa;AAAA,QACnC,QAAQ;AAAA,UACN,aAAa;AAAA;;MAGjB,SACE;AAAA,MACF,SACE;AAAA,MACF,SAAS;AAAA,MACT,QACE;AAAA,MACF,UAAU;AAAA,MACV,aAAa;AAAA;AAEf,UAAM,UAAU,OAAO,sBAAsB,EAAE,OAC7C,iBACA,OAAO,OAAO,MAAM,UAAU;AAChC,UAAM,UAAU,KAAK,MAAM,UAAU;AAAA,EACvC;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/q-CaOqHsqz.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"q-CaOqHsqz.js","sources":["../node_modules/refractor/lang/q.js"],"sourcesContent":["'use strict'\n\nmodule.exports = q\nq.displayName = 'q'\nq.aliases = []\nfunction q(Prism) {\n  Prism.languages.q = {\n    string: /\"(?:\\\\.|[^\"\\\\\\r\\n])*\"/,\n    comment: [\n      // From http://code.kx.com/wiki/Reference/Slash:\n      // When / is following a space (or a right parenthesis, bracket, or brace), it is ignored with the rest of the line.\n      {\n        pattern: /([\\t )\\]}])\\/.*/,\n        lookbehind: true,\n        greedy: true\n      }, // From http://code.kx.com/wiki/Reference/Slash:\n      // A line which has / as its first character and contains at least one other non-whitespace character is a whole-line comment and is ignored entirely.\n      // A / on a line by itself begins a multiline comment which is terminated by the next \\ on a line by itself.\n      // If a / is not matched by a \\, the multiline comment is unterminated and continues to end of file.\n      // The / and \\ must be the first char on the line, but may be followed by any amount of whitespace.\n      {\n        pattern:\n          /(^|\\r?\\n|\\r)\\/[\\t ]*(?:(?:\\r?\\n|\\r)(?:.*(?:\\r?\\n|\\r(?!\\n)))*?(?:\\\\(?=[\\t ]*(?:\\r?\\n|\\r))|$)|\\S.*)/,\n        lookbehind: true,\n        greedy: true\n      }, // From http://code.kx.com/wiki/Reference/Slash:\n      // A \\ on a line by itself with no preceding matching / will comment to end of file.\n      {\n        pattern: /^\\\\[\\t ]*(?:\\r?\\n|\\r)[\\s\\S]+/m,\n        greedy: true\n      },\n      {\n        pattern: /^#!.+/m,\n        greedy: true\n      }\n    ],\n    symbol: /`(?::\\S+|[\\w.]*)/,\n    datetime: {\n      pattern:\n        /0N[mdzuvt]|0W[dtz]|\\d{4}\\.\\d\\d(?:m|\\.\\d\\d(?:T(?:\\d\\d(?::\\d\\d(?::\\d\\d(?:[.:]\\d\\d\\d)?)?)?)?)?[dz]?)|\\d\\d:\\d\\d(?::\\d\\d(?:[.:]\\d\\d\\d)?)?[uvt]?/,\n      alias: 'number'\n    },\n    // The negative look-ahead prevents bad highlighting\n    // of verbs 0: and 1:\n    number:\n      /\\b(?![01]:)(?:0N[hje]?|0W[hj]?|0[wn]|0x[\\da-fA-F]+|\\d+(?:\\.\\d*)?(?:e[+-]?\\d+)?[hjfeb]?)/,\n    keyword:\n      /\\\\\\w+\\b|\\b(?:abs|acos|aj0?|all|and|any|asc|asin|asof|atan|attr|avgs?|binr?|by|ceiling|cols|cor|cos|count|cov|cross|csv|cut|delete|deltas|desc|dev|differ|distinct|div|do|dsave|ej|enlist|eval|except|exec|exit|exp|fby|fills|first|fkeys|flip|floor|from|get|getenv|group|gtime|hclose|hcount|hdel|hopen|hsym|iasc|identity|idesc|if|ij|in|insert|inter|inv|keys?|last|like|list|ljf?|load|log|lower|lsq|ltime|ltrim|mavg|maxs?|mcount|md5|mdev|med|meta|mins?|mmax|mmin|mmu|mod|msum|neg|next|not|null|or|over|parse|peach|pj|plist|prds?|prev|prior|rand|rank|ratios|raze|read0|read1|reciprocal|reval|reverse|rload|rotate|rsave|rtrim|save|scan|scov|sdev|select|set|setenv|show|signum|sin|sqrt|ssr?|string|sublist|sums?|sv|svar|system|tables|tan|til|trim|txf|type|uj|ungroup|union|update|upper|upsert|value|var|views?|vs|wavg|where|while|within|wj1?|wsum|ww|xasc|xbar|xcols?|xdesc|xexp|xgroup|xkey|xlog|xprev|xrank)\\b/,\n    adverb: {\n      pattern: /['\\/\\\\]:?|\\beach\\b/,\n      alias: 'function'\n    },\n    verb: {\n      pattern: /(?:\\B\\.\\B|\\b[01]:|<[=>]?|>=?|[:+\\-*%,!?~=|$&#@^]):?|\\b_\\b:?/,\n      alias: 'operator'\n    },\n    punctuation: /[(){}\\[\\];.]/\n  }\n}\n"],"names":["q"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,QAAiBA;AACjB,EAAAA,GAAE,cAAc;AAChB,EAAAA,GAAE,UAAU,CAAA;AACZ,WAASA,GAAE,OAAO;AAChB,UAAM,UAAU,IAAI;AAAA,MAClB,QAAQ;AAAA,MACR,SAAS;AAAA;AAAA;AAAA,QAGP;AAAA,UACE,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA;;;;;;QAMV;AAAA,UACE,SACE;AAAA,UACF,YAAY;AAAA,UACZ,QAAQ;AAAA;;;QAGV;AAAA,UACE,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV;AAAA,UACE,SAAS;AAAA,UACT,QAAQ;AAAA;;MAGZ,QAAQ;AAAA,MACR,UAAU;AAAA,QACR,SACE;AAAA,QACF,OAAO;AAAA;;;MAIT,QACE;AAAA,MACF,SACE;AAAA,MACF,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,OAAO;AAAA;MAET,MAAM;AAAA,QACJ,SAAS;AAAA,QACT,OAAO;AAAA;MAET,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/qml-DI1TmK3Z.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"qml-DI1TmK3Z.js","sources":["../node_modules/refractor/lang/qml.js"],"sourcesContent":["'use strict'\n\nmodule.exports = qml\nqml.displayName = 'qml'\nqml.aliases = []\nfunction qml(Prism) {\n  ;(function (Prism) {\n    var jsString = /\"(?:\\\\.|[^\\\\\"\\r\\n])*\"|'(?:\\\\.|[^\\\\'\\r\\n])*'/.source\n    var jsComment = /\\/\\/.*(?!.)|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\//.source\n    var jsExpr =\n      /(?:[^\\\\()[\\]{}\"'/]|<string>|\\/(?![*/])|<comment>|\\(<expr>*\\)|\\[<expr>*\\]|\\{<expr>*\\}|\\\\[\\s\\S])/.source\n        .replace(/<string>/g, function () {\n          return jsString\n        })\n        .replace(/<comment>/g, function () {\n          return jsComment\n        }) // the pattern will blow up, so only a few iterations\n    for (var i = 0; i < 2; i++) {\n      jsExpr = jsExpr.replace(/<expr>/g, function () {\n        return jsExpr\n      })\n    }\n    jsExpr = jsExpr.replace(/<expr>/g, '[^\\\\s\\\\S]')\n    Prism.languages.qml = {\n      comment: {\n        pattern: /\\/\\/.*|\\/\\*[\\s\\S]*?\\*\\//,\n        greedy: true\n      },\n      'javascript-function': {\n        pattern: RegExp(\n          /((?:^|;)[ \\t]*)function\\s+(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*\\s*\\(<js>*\\)\\s*\\{<js>*\\}/.source.replace(\n            /<js>/g,\n            function () {\n              return jsExpr\n            }\n          ),\n          'm'\n        ),\n        lookbehind: true,\n        greedy: true,\n        alias: 'language-javascript',\n        inside: Prism.languages.javascript\n      },\n      'class-name': {\n        pattern: /((?:^|[:;])[ \\t]*)(?!\\d)\\w+(?=[ \\t]*\\{|[ \\t]+on\\b)/m,\n        lookbehind: true\n      },\n      property: [\n        {\n          pattern: /((?:^|[;{])[ \\t]*)(?!\\d)\\w+(?:\\.\\w+)*(?=[ \\t]*:)/m,\n          lookbehind: true\n        },\n        {\n          pattern:\n            /((?:^|[;{])[ \\t]*)property[ \\t]+(?!\\d)\\w+(?:\\.\\w+)*[ \\t]+(?!\\d)\\w+(?:\\.\\w+)*(?=[ \\t]*:)/m,\n          lookbehind: true,\n          inside: {\n            keyword: /^property/,\n            property: /\\w+(?:\\.\\w+)*/\n          }\n        }\n      ],\n      'javascript-expression': {\n        pattern: RegExp(\n          /(:[ \\t]*)(?![\\s;}[])(?:(?!$|[;}])<js>)+/.source.replace(\n            /<js>/g,\n            function () {\n              return jsExpr\n            }\n          ),\n          'm'\n        ),\n        lookbehind: true,\n        greedy: true,\n        alias: 'language-javascript',\n        inside: Prism.languages.javascript\n      },\n      string: {\n        pattern: /\"(?:\\\\.|[^\\\\\"\\r\\n])*\"/,\n        greedy: true\n      },\n      keyword: /\\b(?:as|import|on)\\b/,\n      punctuation: /[{}[\\]:;,]/\n    }\n  })(Prism)\n}\n"],"names":["qml","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,UAAiBA;AACjB,EAAAA,KAAI,cAAc;AAClB,EAAAA,KAAI,UAAU,CAAA;AACd,WAASA,KAAI,OAAO;AACjB,KAAC,SAAUC,QAAO;AACjB,UAAI,WAAW,8CAA8C;AAC7D,UAAI,YAAY,yCAAyC;AACzD,UAAI,SACF,iGAAiG,OAC9F,QAAQ,aAAa,WAAY;AAChC,eAAO;AAAA,MACjB,CAAS,EACA,QAAQ,cAAc,WAAY;AACjC,eAAO;AAAA,MACjB,CAAS;AACL,eAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AAC1B,iBAAS,OAAO,QAAQ,WAAW,WAAY;AAC7C,iBAAO;AAAA,QACf,CAAO;AAAA,MACP;AACI,eAAS,OAAO,QAAQ,WAAW,WAAW;AAC9C,MAAAA,OAAM,UAAU,MAAM;AAAA,QACpB,SAAS;AAAA,UACP,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV,uBAAuB;AAAA,UACrB,SAAS;AAAA,YACP,2GAA2G,OAAO;AAAA,cAChH;AAAA,cACA,WAAY;AACV,uBAAO;AAAA,cACrB;AAAA;YAEU;AAAA;UAEF,YAAY;AAAA,UACZ,QAAQ;AAAA,UACR,OAAO;AAAA,UACP,QAAQA,OAAM,UAAU;AAAA;QAE1B,cAAc;AAAA,UACZ,SAAS;AAAA,UACT,YAAY;AAAA;QAEd,UAAU;AAAA,UACR;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA;UAEd;AAAA,YACE,SACE;AAAA,YACF,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,SAAS;AAAA,cACT,UAAU;AAAA;;;QAIhB,yBAAyB;AAAA,UACvB,SAAS;AAAA,YACP,0CAA0C,OAAO;AAAA,cAC/C;AAAA,cACA,WAAY;AACV,uBAAO;AAAA,cACrB;AAAA;YAEU;AAAA;UAEF,YAAY;AAAA,UACZ,QAAQ;AAAA,UACR,OAAO;AAAA,UACP,QAAQA,OAAM,UAAU;AAAA;QAE1B,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV,SAAS;AAAA,QACT,aAAa;AAAA;IAEnB,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/qore-BlFoutGJ.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"qore-BlFoutGJ.js","sources":["../node_modules/refractor/lang/qore.js"],"sourcesContent":["'use strict'\n\nmodule.exports = qore\nqore.displayName = 'qore'\nqore.aliases = []\nfunction qore(Prism) {\n  Prism.languages.qore = Prism.languages.extend('clike', {\n    comment: {\n      pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?\\*\\/|(?:\\/\\/|#).*)/,\n      lookbehind: true\n    },\n    // Overridden to allow unescaped multi-line strings\n    string: {\n      pattern: /(\"|')(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1/,\n      greedy: true\n    },\n    keyword:\n      /\\b(?:abstract|any|assert|binary|bool|boolean|break|byte|case|catch|char|class|code|const|continue|data|default|do|double|else|enum|extends|final|finally|float|for|goto|hash|if|implements|import|inherits|instanceof|int|interface|long|my|native|new|nothing|null|object|our|own|private|reference|rethrow|return|short|soft(?:bool|date|float|int|list|number|string)|static|strictfp|string|sub|super|switch|synchronized|this|throw|throws|transient|try|void|volatile|while)\\b/,\n    boolean: /\\b(?:false|true)\\b/i,\n    function: /\\$?\\b(?!\\d)\\w+(?=\\()/,\n    number:\n      /\\b(?:0b[01]+|0x(?:[\\da-f]*\\.)?[\\da-fp\\-]+|(?:\\d+(?:\\.\\d+)?|\\.\\d+)(?:e\\d+)?[df]|(?:\\d+(?:\\.\\d+)?|\\.\\d+))\\b/i,\n    operator: {\n      pattern:\n        /(^|[^.])(?:\\+[+=]?|-[-=]?|[!=](?:==?|~)?|>>?=?|<(?:=>?|<=?)?|&[&=]?|\\|[|=]?|[*\\/%^]=?|[~?])/,\n      lookbehind: true\n    },\n    variable: /\\$(?!\\d)\\w+\\b/\n  })\n}\n"],"names":["qore"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AACnB,UAAM,UAAU,OAAO,MAAM,UAAU,OAAO,SAAS;AAAA,MACrD,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA;;MAGd,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,SACE;AAAA,MACF,SAAS;AAAA,MACT,UAAU;AAAA,MACV,QACE;AAAA,MACF,UAAU;AAAA,QACR,SACE;AAAA,QACF,YAAY;AAAA;MAEd,UAAU;AAAA,IACd,CAAG;AAAA,EACH;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/qsharp-D3faMIse.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"qsharp-D3faMIse.js","sources":["../node_modules/refractor/lang/qsharp.js"],"sourcesContent":["'use strict'\n\nmodule.exports = qsharp\nqsharp.displayName = 'qsharp'\nqsharp.aliases = ['qs']\nfunction qsharp(Prism) {\n  ;(function (Prism) {\n    /**\n     * Replaces all placeholders \"<<n>>\" of given pattern with the n-th replacement (zero based).\n     *\n     * Note: This is a simple text based replacement. Be careful when using backreferences!\n     *\n     * @param {string} pattern the given pattern.\n     * @param {string[]} replacements a list of replacement which can be inserted into the given pattern.\n     * @returns {string} the pattern with all placeholders replaced with their corresponding replacements.\n     * @example replace(/a<<0>>a/.source, [/b+/.source]) === /a(?:b+)a/.source\n     */\n    function replace(pattern, replacements) {\n      return pattern.replace(/<<(\\d+)>>/g, function (m, index) {\n        return '(?:' + replacements[+index] + ')'\n      })\n    }\n    /**\n     * @param {string} pattern\n     * @param {string[]} replacements\n     * @param {string} [flags]\n     * @returns {RegExp}\n     */\n    function re(pattern, replacements, flags) {\n      return RegExp(replace(pattern, replacements), flags || '')\n    }\n    /**\n     * Creates a nested pattern where all occurrences of the string `<<self>>` are replaced with the pattern itself.\n     *\n     * @param {string} pattern\n     * @param {number} depthLog2\n     * @returns {string}\n     */\n    function nested(pattern, depthLog2) {\n      for (var i = 0; i < depthLog2; i++) {\n        pattern = pattern.replace(/<<self>>/g, function () {\n          return '(?:' + pattern + ')'\n        })\n      }\n      return pattern.replace(/<<self>>/g, '[^\\\\s\\\\S]')\n    } // https://docs.microsoft.com/en-us/azure/quantum/user-guide/language/typesystem/\n    // https://github.com/microsoft/qsharp-language/tree/main/Specifications/Language/5_Grammar\n    var keywordKinds = {\n      // keywords which represent a return or variable type\n      type: 'Adj BigInt Bool Ctl Double false Int One Pauli PauliI PauliX PauliY PauliZ Qubit Range Result String true Unit Zero',\n      // all other keywords\n      other:\n        'Adjoint adjoint apply as auto body borrow borrowing Controlled controlled distribute elif else fail fixup for function if in internal intrinsic invert is let mutable namespace new newtype open operation repeat return self set until use using while within'\n    } // keywords\n    function keywordsToPattern(words) {\n      return '\\\\b(?:' + words.trim().replace(/ /g, '|') + ')\\\\b'\n    }\n    var keywords = RegExp(\n      keywordsToPattern(keywordKinds.type + ' ' + keywordKinds.other)\n    ) // types\n    var identifier = /\\b[A-Za-z_]\\w*\\b/.source\n    var qualifiedName = replace(/<<0>>(?:\\s*\\.\\s*<<0>>)*/.source, [identifier])\n    var typeInside = {\n      keyword: keywords,\n      punctuation: /[<>()?,.:[\\]]/\n    } // strings\n    var regularString = /\"(?:\\\\.|[^\\\\\"])*\"/.source\n    Prism.languages.qsharp = Prism.languages.extend('clike', {\n      comment: /\\/\\/.*/,\n      string: [\n        {\n          pattern: re(/(^|[^$\\\\])<<0>>/.source, [regularString]),\n          lookbehind: true,\n          greedy: true\n        }\n      ],\n      'class-name': [\n        {\n          // open Microsoft.Quantum.Canon;\n          // open Microsoft.Quantum.Canon as CN;\n          pattern: re(/(\\b(?:as|open)\\s+)<<0>>(?=\\s*(?:;|as\\b))/.source, [\n            qualifiedName\n          ]),\n          lookbehind: true,\n          inside: typeInside\n        },\n        {\n          // namespace Quantum.App1;\n          pattern: re(/(\\bnamespace\\s+)<<0>>(?=\\s*\\{)/.source, [qualifiedName]),\n          lookbehind: true,\n          inside: typeInside\n        }\n      ],\n      keyword: keywords,\n      number:\n        /(?:\\b0(?:x[\\da-f]+|b[01]+|o[0-7]+)|(?:\\B\\.\\d+|\\b\\d+(?:\\.\\d*)?)(?:e[-+]?\\d+)?)l?\\b/i,\n      operator:\n        /\\band=|\\bor=|\\band\\b|\\bnot\\b|\\bor\\b|<[-=]|[-=]>|>>>=?|<<<=?|\\^\\^\\^=?|\\|\\|\\|=?|&&&=?|w\\/=?|~~~|[*\\/+\\-^=!%]=?/,\n      punctuation: /::|[{}[\\];(),.:]/\n    })\n    Prism.languages.insertBefore('qsharp', 'number', {\n      range: {\n        pattern: /\\.\\./,\n        alias: 'operator'\n      }\n    }) // single line\n    var interpolationExpr = nested(\n      replace(/\\{(?:[^\"{}]|<<0>>|<<self>>)*\\}/.source, [regularString]),\n      2\n    )\n    Prism.languages.insertBefore('qsharp', 'string', {\n      'interpolation-string': {\n        pattern: re(/\\$\"(?:\\\\.|<<0>>|[^\\\\\"{])*\"/.source, [interpolationExpr]),\n        greedy: true,\n        inside: {\n          interpolation: {\n            pattern: re(/((?:^|[^\\\\])(?:\\\\\\\\)*)<<0>>/.source, [\n              interpolationExpr\n            ]),\n            lookbehind: true,\n            inside: {\n              punctuation: /^\\{|\\}$/,\n              expression: {\n                pattern: /[\\s\\S]+/,\n                alias: 'language-qsharp',\n                inside: Prism.languages.qsharp\n              }\n            }\n          },\n          string: /[\\s\\S]+/\n        }\n      }\n    })\n  })(Prism)\n  Prism.languages.qs = Prism.languages.qsharp\n}\n"],"names":["qsharp","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAC,IAAI;AACtB,WAASA,QAAO,OAAO;AACpB,KAAC,SAAUC,QAAO;AAWjB,eAAS,QAAQ,SAAS,cAAc;AACtC,eAAO,QAAQ,QAAQ,cAAc,SAAU,GAAG,OAAO;AACvD,iBAAO,QAAQ,aAAa,CAAC,KAAK,IAAI;AAAA,QAC9C,CAAO;AAAA,MACP;AAOI,eAAS,GAAG,SAAS,cAAc,OAAO;AACxC,eAAO,OAAO,QAAQ,SAAS,YAAY,GAAY,EAAE;AAAA,MAC/D;AAQI,eAAS,OAAO,SAAS,WAAW;AAClC,iBAAS,IAAI,GAAG,IAAI,WAAW,KAAK;AAClC,oBAAU,QAAQ,QAAQ,aAAa,WAAY;AACjD,mBAAO,QAAQ,UAAU;AAAA,UACnC,CAAS;AAAA,QACT;AACM,eAAO,QAAQ,QAAQ,aAAa,WAAW;AAAA,MACrD;AAEI,UAAI,eAAe;AAAA;AAAA,QAEjB,MAAM;AAAA;AAAA,QAEN,OACE;AAAA;AAEJ,eAAS,kBAAkB,OAAO;AAChC,eAAO,WAAW,MAAM,KAAI,EAAG,QAAQ,MAAM,GAAG,IAAI;AAAA,MAC1D;AACI,UAAI,WAAW;AAAA,QACb,kBAAkB,aAAa,OAAO,MAAM,aAAa,KAAK;AAAA;AAEhE,UAAI,aAAa,mBAAmB;AACpC,UAAI,gBAAgB,QAAQ,0BAA0B,QAAQ,CAAC,UAAU,CAAC;AAC1E,UAAI,aAAa;AAAA,QACf,SAAS;AAAA,QACT,aAAa;AAAA;AAEf,UAAI,gBAAgB,oBAAoB;AACxC,MAAAA,OAAM,UAAU,SAASA,OAAM,UAAU,OAAO,SAAS;AAAA,QACvD,SAAS;AAAA,QACT,QAAQ;AAAA,UACN;AAAA,YACE,SAAS,GAAG,kBAAkB,QAAQ,CAAC,aAAa,CAAC;AAAA,YACrD,YAAY;AAAA,YACZ,QAAQ;AAAA;;QAGZ,cAAc;AAAA,UACZ;AAAA;AAAA;AAAA,YAGE,SAAS,GAAG,2CAA2C,QAAQ;AAAA,cAC7D;AAAA,YACZ,CAAW;AAAA,YACD,YAAY;AAAA,YACZ,QAAQ;AAAA;UAEV;AAAA;AAAA,YAEE,SAAS,GAAG,iCAAiC,QAAQ,CAAC,aAAa,CAAC;AAAA,YACpE,YAAY;AAAA,YACZ,QAAQ;AAAA;;QAGZ,SAAS;AAAA,QACT,QACE;AAAA,QACF,UACE;AAAA,QACF,aAAa;AAAA,MACnB,CAAK;AACD,MAAAA,OAAM,UAAU,aAAa,UAAU,UAAU;AAAA,QAC/C,OAAO;AAAA,UACL,SAAS;AAAA,UACT,OAAO;AAAA;MAEf,CAAK;AACD,UAAI,oBAAoB;AAAA,QACtB,QAAQ,iCAAiC,QAAQ,CAAC,aAAa,CAAC;AAAA,QAChE;AAAA;AAEF,MAAAA,OAAM,UAAU,aAAa,UAAU,UAAU;AAAA,QAC/C,wBAAwB;AAAA,UACtB,SAAS,GAAG,6BAA6B,QAAQ,CAAC,iBAAiB,CAAC;AAAA,UACpE,QAAQ;AAAA,UACR,QAAQ;AAAA,YACN,eAAe;AAAA,cACb,SAAS,GAAG,8BAA8B,QAAQ;AAAA,gBAChD;AAAA,cACd,CAAa;AAAA,cACD,YAAY;AAAA,cACZ,QAAQ;AAAA,gBACN,aAAa;AAAA,gBACb,YAAY;AAAA,kBACV,SAAS;AAAA,kBACT,OAAO;AAAA,kBACP,QAAQA,OAAM,UAAU;AAAA;;;YAI9B,QAAQ;AAAA;;MAGlB,CAAK;AAAA,IACL,GAAK,KAAK;AACR,UAAM,UAAU,KAAK,MAAM,UAAU;AAAA,EACvC;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/r-B2OJCmF9.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"r-B2OJCmF9.js","sources":["../node_modules/refractor/lang/r.js"],"sourcesContent":["'use strict'\n\nmodule.exports = r\nr.displayName = 'r'\nr.aliases = []\nfunction r(Prism) {\n  Prism.languages.r = {\n    comment: /#.*/,\n    string: {\n      pattern: /(['\"])(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/,\n      greedy: true\n    },\n    'percent-operator': {\n      // Includes user-defined operators\n      // and %%, %*%, %/%, %in%, %o%, %x%\n      pattern: /%[^%\\s]*%/,\n      alias: 'operator'\n    },\n    boolean: /\\b(?:FALSE|TRUE)\\b/,\n    ellipsis: /\\.\\.(?:\\.|\\d+)/,\n    number: [\n      /\\b(?:Inf|NaN)\\b/,\n      /(?:\\b0x[\\dA-Fa-f]+(?:\\.\\d*)?|\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:[EePp][+-]?\\d+)?[iL]?/\n    ],\n    keyword:\n      /\\b(?:NA|NA_character_|NA_complex_|NA_integer_|NA_real_|NULL|break|else|for|function|if|in|next|repeat|while)\\b/,\n    operator: /->?>?|<(?:=|<?-)?|[>=!]=?|::?|&&?|\\|\\|?|[+*\\/^$@~]/,\n    punctuation: /[(){}\\[\\],;]/\n  }\n}\n"],"names":["r"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,QAAiBA;AACjB,EAAAA,GAAE,cAAc;AAChB,EAAAA,GAAE,UAAU,CAAA;AACZ,WAASA,GAAE,OAAO;AAChB,UAAM,UAAU,IAAI;AAAA,MAClB,SAAS;AAAA,MACT,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,oBAAoB;AAAA;AAAA;AAAA,QAGlB,SAAS;AAAA,QACT,OAAO;AAAA;MAET,SAAS;AAAA,MACT,UAAU;AAAA,MACV,QAAQ;AAAA,QACN;AAAA,QACA;AAAA;MAEF,SACE;AAAA,MACF,UAAU;AAAA,MACV,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/racket-Bsw-qBt0.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"racket-Bsw-qBt0.js","sources":["../node_modules/refractor/lang/racket.js"],"sourcesContent":["'use strict'\nvar refractorScheme = require('./scheme.js')\nmodule.exports = racket\nracket.displayName = 'racket'\nracket.aliases = ['rkt']\nfunction racket(Prism) {\n  Prism.register(refractorScheme)\n  Prism.languages.racket = Prism.languages.extend('scheme', {\n    'lambda-parameter': {\n      // the racket lambda syntax is a lot more complex, so we won't even attempt to capture it.\n      // this will just prevent false positives of the `function` pattern\n      pattern: /([(\\[]lambda\\s+[(\\[])[^()\\[\\]'\\s]+/,\n      lookbehind: true\n    }\n  })\n  Prism.languages.insertBefore('racket', 'string', {\n    lang: {\n      pattern: /^#lang.+/m,\n      greedy: true,\n      alias: 'keyword'\n    }\n  })\n  Prism.languages.rkt = Prism.languages.racket\n}\n"],"names":["require$$0","racket"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,kBAAkBA,cAAA;AACtB,aAAiBC;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAC,KAAK;AACvB,WAASA,QAAO,OAAO;AACrB,UAAM,SAAS,eAAe;AAC9B,UAAM,UAAU,SAAS,MAAM,UAAU,OAAO,UAAU;AAAA,MACxD,oBAAoB;AAAA;AAAA;AAAA,QAGlB,SAAS;AAAA,QACT,YAAY;AAAA;IAElB,CAAG;AACD,UAAM,UAAU,aAAa,UAAU,UAAU;AAAA,MAC/C,MAAM;AAAA,QACJ,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,OAAO;AAAA;IAEb,CAAG;AACD,UAAM,UAAU,MAAM,MAAM,UAAU;AAAA,EACxC;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/reason-CtbzBXQG.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"reason-CtbzBXQG.js","sources":["../node_modules/refractor/lang/reason.js"],"sourcesContent":["'use strict'\n\nmodule.exports = reason\nreason.displayName = 'reason'\nreason.aliases = []\nfunction reason(Prism) {\n  Prism.languages.reason = Prism.languages.extend('clike', {\n    string: {\n      pattern: /\"(?:\\\\(?:\\r\\n|[\\s\\S])|[^\\\\\\r\\n\"])*\"/,\n      greedy: true\n    },\n    // 'class-name' must be matched *after* 'constructor' defined below\n    'class-name': /\\b[A-Z]\\w*/,\n    keyword:\n      /\\b(?:and|as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|method|module|mutable|new|nonrec|object|of|open|or|private|rec|sig|struct|switch|then|to|try|type|val|virtual|when|while|with)\\b/,\n    operator:\n      /\\.{3}|:[:=]|\\|>|->|=(?:==?|>)?|<=?|>=?|[|^?'#!~`]|[+\\-*\\/]\\.?|\\b(?:asr|land|lor|lsl|lsr|lxor|mod)\\b/\n  })\n  Prism.languages.insertBefore('reason', 'class-name', {\n    char: {\n      pattern: /'(?:\\\\x[\\da-f]{2}|\\\\o[0-3][0-7][0-7]|\\\\\\d{3}|\\\\.|[^'\\\\\\r\\n])'/,\n      greedy: true\n    },\n    // Negative look-ahead prevents from matching things like String.capitalize\n    constructor: /\\b[A-Z]\\w*\\b(?!\\s*\\.)/,\n    label: {\n      pattern: /\\b[a-z]\\w*(?=::)/,\n      alias: 'symbol'\n    }\n  }) // We can't match functions property, so let's not even try.\n  delete Prism.languages.reason.function\n}\n"],"names":["reason"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAA;AACjB,WAASA,QAAO,OAAO;AACrB,UAAM,UAAU,SAAS,MAAM,UAAU,OAAO,SAAS;AAAA,MACvD,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;;MAGV,cAAc;AAAA,MACd,SACE;AAAA,MACF,UACE;AAAA,IACN,CAAG;AACD,UAAM,UAAU,aAAa,UAAU,cAAc;AAAA,MACnD,MAAM;AAAA,QACJ,SAAS;AAAA,QACT,QAAQ;AAAA;;MAGV,aAAa;AAAA,MACb,OAAO;AAAA,QACL,SAAS;AAAA,QACT,OAAO;AAAA;IAEb,CAAG;AACD,WAAO,MAAM,UAAU,OAAO;AAAA,EAChC;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/regex-V8nUstuk.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"regex-V8nUstuk.js","sources":["../node_modules/refractor/lang/regex.js"],"sourcesContent":["'use strict'\n\nmodule.exports = regex\nregex.displayName = 'regex'\nregex.aliases = []\nfunction regex(Prism) {\n  ;(function (Prism) {\n    var specialEscape = {\n      pattern: /\\\\[\\\\(){}[\\]^$+*?|.]/,\n      alias: 'escape'\n    }\n    var escape =\n      /\\\\(?:x[\\da-fA-F]{2}|u[\\da-fA-F]{4}|u\\{[\\da-fA-F]+\\}|0[0-7]{0,2}|[123][0-7]{2}|c[a-zA-Z]|.)/\n    var charSet = {\n      pattern: /\\.|\\\\[wsd]|\\\\p\\{[^{}]+\\}/i,\n      alias: 'class-name'\n    }\n    var charSetWithoutDot = {\n      pattern: /\\\\[wsd]|\\\\p\\{[^{}]+\\}/i,\n      alias: 'class-name'\n    }\n    var rangeChar = '(?:[^\\\\\\\\-]|' + escape.source + ')'\n    var range = RegExp(rangeChar + '-' + rangeChar) // the name of a capturing group\n    var groupName = {\n      pattern: /(<|')[^<>']+(?=[>']$)/,\n      lookbehind: true,\n      alias: 'variable'\n    }\n    Prism.languages.regex = {\n      'char-class': {\n        pattern: /((?:^|[^\\\\])(?:\\\\\\\\)*)\\[(?:[^\\\\\\]]|\\\\[\\s\\S])*\\]/,\n        lookbehind: true,\n        inside: {\n          'char-class-negation': {\n            pattern: /(^\\[)\\^/,\n            lookbehind: true,\n            alias: 'operator'\n          },\n          'char-class-punctuation': {\n            pattern: /^\\[|\\]$/,\n            alias: 'punctuation'\n          },\n          range: {\n            pattern: range,\n            inside: {\n              escape: escape,\n              'range-punctuation': {\n                pattern: /-/,\n                alias: 'operator'\n              }\n            }\n          },\n          'special-escape': specialEscape,\n          'char-set': charSetWithoutDot,\n          escape: escape\n        }\n      },\n      'special-escape': specialEscape,\n      'char-set': charSet,\n      backreference: [\n        {\n          // a backreference which is not an octal escape\n          pattern: /\\\\(?![123][0-7]{2})[1-9]/,\n          alias: 'keyword'\n        },\n        {\n          pattern: /\\\\k<[^<>']+>/,\n          alias: 'keyword',\n          inside: {\n            'group-name': groupName\n          }\n        }\n      ],\n      anchor: {\n        pattern: /[$^]|\\\\[ABbGZz]/,\n        alias: 'function'\n      },\n      escape: escape,\n      group: [\n        {\n          // https://docs.oracle.com/javase/10/docs/api/java/util/regex/Pattern.html\n          // https://docs.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-language-quick-reference?view=netframework-4.7.2#grouping-constructs\n          // (), (?<name>), (?'name'), (?>), (?:), (?=), (?!), (?<=), (?<!), (?is-m), (?i-m:)\n          pattern:\n            /\\((?:\\?(?:<[^<>']+>|'[^<>']+'|[>:]|<?[=!]|[idmnsuxU]+(?:-[idmnsuxU]+)?:?))?/,\n          alias: 'punctuation',\n          inside: {\n            'group-name': groupName\n          }\n        },\n        {\n          pattern: /\\)/,\n          alias: 'punctuation'\n        }\n      ],\n      quantifier: {\n        pattern: /(?:[+*?]|\\{\\d+(?:,\\d*)?\\})[?+]?/,\n        alias: 'number'\n      },\n      alternation: {\n        pattern: /\\|/,\n        alias: 'keyword'\n      }\n    }\n  })(Prism)\n}\n"],"names":["regex","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,YAAiBA;AACjB,EAAAA,OAAM,cAAc;AACpB,EAAAA,OAAM,UAAU,CAAA;AAChB,WAASA,OAAM,OAAO;AACnB,KAAC,SAAUC,QAAO;AACjB,UAAI,gBAAgB;AAAA,QAClB,SAAS;AAAA,QACT,OAAO;AAAA;AAET,UAAI,SACF;AACF,UAAI,UAAU;AAAA,QACZ,SAAS;AAAA,QACT,OAAO;AAAA;AAET,UAAI,oBAAoB;AAAA,QACtB,SAAS;AAAA,QACT,OAAO;AAAA;AAET,UAAI,YAAY,iBAAiB,OAAO,SAAS;AACjD,UAAI,QAAQ,OAAO,YAAY,MAAM,SAAS;AAC9C,UAAI,YAAY;AAAA,QACd,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA;AAET,MAAAA,OAAM,UAAU,QAAQ;AAAA,QACtB,cAAc;AAAA,UACZ,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN,uBAAuB;AAAA,cACrB,SAAS;AAAA,cACT,YAAY;AAAA,cACZ,OAAO;AAAA;YAET,0BAA0B;AAAA,cACxB,SAAS;AAAA,cACT,OAAO;AAAA;YAET,OAAO;AAAA,cACL,SAAS;AAAA,cACT,QAAQ;AAAA,gBACN;AAAA,gBACA,qBAAqB;AAAA,kBACnB,SAAS;AAAA,kBACT,OAAO;AAAA;;;YAIb,kBAAkB;AAAA,YAClB,YAAY;AAAA,YACZ;AAAA;;QAGJ,kBAAkB;AAAA,QAClB,YAAY;AAAA,QACZ,eAAe;AAAA,UACb;AAAA;AAAA,YAEE,SAAS;AAAA,YACT,OAAO;AAAA;UAET;AAAA,YACE,SAAS;AAAA,YACT,OAAO;AAAA,YACP,QAAQ;AAAA,cACN,cAAc;AAAA;;;QAIpB,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,OAAO;AAAA;QAET;AAAA,QACA,OAAO;AAAA,UACL;AAAA;AAAA;AAAA;AAAA,YAIE,SACE;AAAA,YACF,OAAO;AAAA,YACP,QAAQ;AAAA,cACN,cAAc;AAAA;;UAGlB;AAAA,YACE,SAAS;AAAA,YACT,OAAO;AAAA;;QAGX,YAAY;AAAA,UACV,SAAS;AAAA,UACT,OAAO;AAAA;QAET,aAAa;AAAA,UACX,SAAS;AAAA,UACT,OAAO;AAAA;;IAGf,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/rego-CsVS9iDu.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"rego-CsVS9iDu.js","sources":["../node_modules/refractor/lang/rego.js"],"sourcesContent":["'use strict'\n\nmodule.exports = rego\nrego.displayName = 'rego'\nrego.aliases = []\nfunction rego(Prism) {\n  // https://www.openpolicyagent.org/docs/latest/policy-reference/\n  Prism.languages.rego = {\n    comment: /#.*/,\n    property: {\n      pattern:\n        /(^|[^\\\\.])(?:\"(?:\\\\.|[^\\\\\"\\r\\n])*\"|`[^`]*`|\\b[a-z_]\\w*\\b)(?=\\s*:(?!=))/i,\n      lookbehind: true,\n      greedy: true\n    },\n    string: {\n      pattern: /(^|[^\\\\])\"(?:\\\\.|[^\\\\\"\\r\\n])*\"|`[^`]*`/,\n      lookbehind: true,\n      greedy: true\n    },\n    keyword:\n      /\\b(?:as|default|else|import|not|null|package|set(?=\\s*\\()|some|with)\\b/,\n    boolean: /\\b(?:false|true)\\b/,\n    function: {\n      pattern: /\\b[a-z_]\\w*\\b(?:\\s*\\.\\s*\\b[a-z_]\\w*\\b)*(?=\\s*\\()/i,\n      inside: {\n        namespace: /\\b\\w+\\b(?=\\s*\\.)/,\n        punctuation: /\\./\n      }\n    },\n    number: /-?\\b\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?\\b/i,\n    operator: /[-+*/%|&]|[<>:=]=?|!=|\\b_\\b/,\n    punctuation: /[,;.\\[\\]{}()]/\n  }\n}\n"],"names":["rego"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AAEnB,UAAM,UAAU,OAAO;AAAA,MACrB,SAAS;AAAA,MACT,UAAU;AAAA,QACR,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA;MAEV,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ;AAAA;MAEV,SACE;AAAA,MACF,SAAS;AAAA,MACT,UAAU;AAAA,QACR,SAAS;AAAA,QACT,QAAQ;AAAA,UACN,WAAW;AAAA,UACX,aAAa;AAAA;;MAGjB,QAAQ;AAAA,MACR,UAAU;AAAA,MACV,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/renpy-DnQVUnNT.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"renpy-DnQVUnNT.js","sources":["../node_modules/refractor/lang/renpy.js"],"sourcesContent":["'use strict'\n\nmodule.exports = renpy\nrenpy.displayName = 'renpy'\nrenpy.aliases = ['rpy']\nfunction renpy(Prism) {\n  Prism.languages.renpy = {\n    comment: {\n      pattern: /(^|[^\\\\])#.+/,\n      lookbehind: true\n    },\n    string: {\n      pattern:\n        /(\"\"\"|''')[\\s\\S]+?\\1|(\"|')(?:\\\\.|(?!\\2)[^\\\\])*\\2|(?:^#?(?:(?:[0-9a-fA-F]){3}|[0-9a-fA-F]{6})$)/m,\n      greedy: true\n    },\n    function: /\\b[a-z_]\\w*(?=\\()/i,\n    property:\n      /\\b(?:Update|UpdateVersion|action|activate_sound|adv_nvl_transition|after_load_transition|align|alpha|alt|anchor|antialias|area|auto|background|bar_invert|bar_resizing|bar_vertical|black_color|bold|bottom_bar|bottom_gutter|bottom_margin|bottom_padding|box_reverse|box_wrap|can_update|caret|child|color|crop|default_afm_enable|default_afm_time|default_fullscreen|default_text_cps|developer|directory_name|drag_handle|drag_joined|drag_name|drag_raise|draggable|dragged|drop_shadow|drop_shadow_color|droppable|dropped|easein|easeout|edgescroll|end_game_transition|end_splash_transition|enter_replay_transition|enter_sound|enter_transition|enter_yesno_transition|executable_name|exit_replay_transition|exit_sound|exit_transition|exit_yesno_transition|fadein|fadeout|first_indent|first_spacing|fit_first|focus|focus_mask|font|foreground|game_main_transition|get_installed_packages|google_play_key|google_play_salt|ground|has_music|has_sound|has_voice|height|help|hinting|hover|hover_background|hover_color|hover_sound|hovered|hyperlink_functions|idle|idle_color|image_style|include_update|insensitive|insensitive_background|insensitive_color|inside|intra_transition|italic|justify|kerning|keyboard_focus|language|layer_clipping|layers|layout|left_bar|left_gutter|left_margin|left_padding|length|line_leading|line_overlap_split|line_spacing|linear|main_game_transition|main_menu_music|maximum|min_width|minimum|minwidth|modal|mouse|mousewheel|name|narrator_menu|newline_indent|nvl_adv_transition|offset|order_reverse|outlines|overlay_functions|pos|position|prefix|radius|range|rest_indent|right_bar|right_gutter|right_margin|right_padding|rotate|rotate_pad|ruby_style|sample_sound|save_directory|say_attribute_transition|screen_height|screen_width|scrollbars|selected_hover|selected_hover_color|selected_idle|selected_idle_color|selected_insensitive|show_side_image|show_two_window|side_spacing|side_xpos|side_ypos|size|size_group|slow_cps|slow_cps_multiplier|spacing|strikethrough|subpixel|text_align|text_style|text_xpos|text_y_fudge|text_ypos|thumb|thumb_offset|thumb_shadow|thumbnail_height|thumbnail_width|time|top_bar|top_gutter|top_margin|top_padding|translations|underline|unscrollable|update|value|version|version_name|version_tuple|vertical|width|window_hide_transition|window_icon|window_left_padding|window_show_transition|window_title|windows_icon|xadjustment|xalign|xanchor|xanchoraround|xaround|xcenter|xfill|xinitial|xmargin|xmaximum|xminimum|xoffset|xofsset|xpadding|xpos|xsize|xzoom|yadjustment|yalign|yanchor|yanchoraround|yaround|ycenter|yfill|yinitial|ymargin|ymaximum|yminimum|yoffset|ypadding|ypos|ysize|ysizexysize|yzoom|zoom|zorder)\\b/,\n    tag: /\\b(?:bar|block|button|buttoscreenn|drag|draggroup|fixed|frame|grid|[hv]box|hotbar|hotspot|image|imagebutton|imagemap|input|key|label|menu|mm_menu_frame|mousearea|nvl|parallel|screen|self|side|tag|text|textbutton|timer|vbar|viewport|window)\\b|\\$/,\n    keyword:\n      /\\b(?:None|add|adjustment|alignaround|allow|angle|animation|around|as|assert|behind|box_layout|break|build|cache|call|center|changed|child_size|choice|circles|class|clear|clicked|clipping|clockwise|config|contains|continue|corner1|corner2|counterclockwise|def|default|define|del|delay|disabled|disabled_text|dissolve|elif|else|event|except|exclude|exec|expression|fade|finally|for|from|function|global|gm_root|has|hide|id|if|import|in|init|is|jump|knot|lambda|left|less_rounded|mm_root|movie|music|null|on|onlayer|pass|pause|persistent|play|print|python|queue|raise|random|renpy|repeat|return|right|rounded_window|scene|scope|set|show|slow|slow_abortable|slow_done|sound|stop|store|style|style_group|substitute|suffix|theme|transform|transform_anchor|transpose|try|ui|unhovered|updater|use|voice|while|widget|widget_hover|widget_selected|widget_text|yield)\\b/,\n    boolean: /\\b(?:[Ff]alse|[Tt]rue)\\b/,\n    number:\n      /(?:\\b(?:0[bo])?(?:(?:\\d|0x[\\da-f])[\\da-f]*(?:\\.\\d*)?)|\\B\\.\\d+)(?:e[+-]?\\d+)?j?/i,\n    operator:\n      /[-+%=]=?|!=|\\*\\*?=?|\\/\\/?=?|<[<=>]?|>[=>]?|[&|^~]|\\b(?:and|at|not|or|with)\\b/,\n    punctuation: /[{}[\\];(),.:]/\n  }\n  Prism.languages.rpy = Prism.languages.renpy\n}\n"],"names":["renpy"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,YAAiBA;AACjB,EAAAA,OAAM,cAAc;AACpB,EAAAA,OAAM,UAAU,CAAC,KAAK;AACtB,WAASA,OAAM,OAAO;AACpB,UAAM,UAAU,QAAQ;AAAA,MACtB,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,QAAQ;AAAA,QACN,SACE;AAAA,QACF,QAAQ;AAAA;MAEV,UAAU;AAAA,MACV,UACE;AAAA,MACF,KAAK;AAAA,MACL,SACE;AAAA,MACF,SAAS;AAAA,MACT,QACE;AAAA,MACF,UACE;AAAA,MACF,aAAa;AAAA;AAEf,UAAM,UAAU,MAAM,MAAM,UAAU;AAAA,EACxC;;;;;;;;;","x_google_ignoreList":[0]}