@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/php-BBLqus8v.js

@@ -0,0 +1,347 @@
+import { r as requireMarkupTemplating } from "./markup-templating-hY-QSL53.js";
+var php_1;
+var hasRequiredPhp;
+function requirePhp() {
+  if (hasRequiredPhp) return php_1;
+  hasRequiredPhp = 1;
+  var refractorMarkupTemplating = requireMarkupTemplating();
+  php_1 = php;
+  php.displayName = "php";
+  php.aliases = [];
+  function php(Prism) {
+    Prism.register(refractorMarkupTemplating);
+    (function(Prism2) {
+      var comment = /\/\*[\s\S]*?\*\/|\/\/.*|#(?!\[).*/;
+      var constant = [
+        {
+          pattern: /\b(?:false|true)\b/i,
+          alias: "boolean"
+        },
+        {
+          pattern: /(::\s*)\b[a-z_]\w*\b(?!\s*\()/i,
+          greedy: true,
+          lookbehind: true
+        },
+        {
+          pattern: /(\b(?:case|const)\s+)\b[a-z_]\w*(?=\s*[;=])/i,
+          greedy: true,
+          lookbehind: true
+        },
+        /\b(?:null)\b/i,
+        /\b[A-Z_][A-Z0-9_]*\b(?!\s*\()/
+      ];
+      var number = /\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;
+      var operator = /<?=>|\?\?=?|\.{3}|\??->|[!=]=?=?|::|\*\*=?|--|\+\+|&&|\|\||<<|>>|[?~]|[/^|%*&<>.+-]=?/;
+      var punctuation = /[{}\[\](),:;]/;
+      Prism2.languages.php = {
+        delimiter: {
+          pattern: /\?>$|^<\?(?:php(?=\s)|=)?/i,
+          alias: "important"
+        },
+        comment,
+        variable: /\$+(?:\w+\b|(?=\{))/,
+        package: {
+          pattern: /(namespace\s+|use\s+(?:function\s+)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+          lookbehind: true,
+          inside: {
+            punctuation: /\\/
+          }
+        },
+        "class-name-definition": {
+          pattern: /(\b(?:class|enum|interface|trait)\s+)\b[a-z_]\w*(?!\\)\b/i,
+          lookbehind: true,
+          alias: "class-name"
+        },
+        "function-definition": {
+          pattern: /(\bfunction\s+)[a-z_]\w*(?=\s*\()/i,
+          lookbehind: true,
+          alias: "function"
+        },
+        keyword: [
+          {
+            pattern: /(\(\s*)\b(?:array|bool|boolean|float|int|integer|object|string)\b(?=\s*\))/i,
+            alias: "type-casting",
+            greedy: true,
+            lookbehind: true
+          },
+          {
+            pattern: /([(,?]\s*)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|object|self|static|string)\b(?=\s*\$)/i,
+            alias: "type-hint",
+            greedy: true,
+            lookbehind: true
+          },
+          {
+            pattern: /(\)\s*:\s*(?:\?\s*)?)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|object|self|static|string|void)\b/i,
+            alias: "return-type",
+            greedy: true,
+            lookbehind: true
+          },
+          {
+            pattern: /\b(?:array(?!\s*\()|bool|float|int|iterable|mixed|object|string|void)\b/i,
+            alias: "type-declaration",
+            greedy: true
+          },
+          {
+            pattern: /(\|\s*)(?:false|null)\b|\b(?:false|null)(?=\s*\|)/i,
+            alias: "type-declaration",
+            greedy: true,
+            lookbehind: true
+          },
+          {
+            pattern: /\b(?:parent|self|static)(?=\s*::)/i,
+            alias: "static-context",
+            greedy: true
+          },
+          {
+            // yield from
+            pattern: /(\byield\s+)from\b/i,
+            lookbehind: true
+          },
+          // `class` is always a keyword unlike other keywords
+          /\bclass\b/i,
+          {
+            // https://www.php.net/manual/en/reserved.keywords.php
+            //
+            // keywords cannot be preceded by "->"
+            // the complex lookbehind means `(?<!(?:->|::)\s*)`
+            pattern: /((?:^|[^\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,
+            lookbehind: true
+          }
+        ],
+        "argument-name": {
+          pattern: /([(,]\s+)\b[a-z_]\w*(?=\s*:(?!:))/i,
+          lookbehind: true
+        },
+        "class-name": [
+          {
+            pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self|\s+static))\s+|\bcatch\s*\()\b[a-z_]\w*(?!\\)\b/i,
+            greedy: true,
+            lookbehind: true
+          },
+          {
+            pattern: /(\|\s*)\b[a-z_]\w*(?!\\)\b/i,
+            greedy: true,
+            lookbehind: true
+          },
+          {
+            pattern: /\b[a-z_]\w*(?!\\)\b(?=\s*\|)/i,
+            greedy: true
+          },
+          {
+            pattern: /(\|\s*)(?:\\?\b[a-z_]\w*)+\b/i,
+            alias: "class-name-fully-qualified",
+            greedy: true,
+            lookbehind: true,
+            inside: {
+              punctuation: /\\/
+            }
+          },
+          {
+            pattern: /(?:\\?\b[a-z_]\w*)+\b(?=\s*\|)/i,
+            alias: "class-name-fully-qualified",
+            greedy: true,
+            inside: {
+              punctuation: /\\/
+            }
+          },
+          {
+            pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self\b|\s+static\b))\s+|\bcatch\s*\()(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+            alias: "class-name-fully-qualified",
+            greedy: true,
+            lookbehind: true,
+            inside: {
+              punctuation: /\\/
+            }
+          },
+          {
+            pattern: /\b[a-z_]\w*(?=\s*\$)/i,
+            alias: "type-declaration",
+            greedy: true
+          },
+          {
+            pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
+            alias: ["class-name-fully-qualified", "type-declaration"],
+            greedy: true,
+            inside: {
+              punctuation: /\\/
+            }
+          },
+          {
+            pattern: /\b[a-z_]\w*(?=\s*::)/i,
+            alias: "static-context",
+            greedy: true
+          },
+          {
+            pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*::)/i,
+            alias: ["class-name-fully-qualified", "static-context"],
+            greedy: true,
+            inside: {
+              punctuation: /\\/
+            }
+          },
+          {
+            pattern: /([(,?]\s*)[a-z_]\w*(?=\s*\$)/i,
+            alias: "type-hint",
+            greedy: true,
+            lookbehind: true
+          },
+          {
+            pattern: /([(,?]\s*)(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
+            alias: ["class-name-fully-qualified", "type-hint"],
+            greedy: true,
+            lookbehind: true,
+            inside: {
+              punctuation: /\\/
+            }
+          },
+          {
+            pattern: /(\)\s*:\s*(?:\?\s*)?)\b[a-z_]\w*(?!\\)\b/i,
+            alias: "return-type",
+            greedy: true,
+            lookbehind: true
+          },
+          {
+            pattern: /(\)\s*:\s*(?:\?\s*)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+            alias: ["class-name-fully-qualified", "return-type"],
+            greedy: true,
+            lookbehind: true,
+            inside: {
+              punctuation: /\\/
+            }
+          }
+        ],
+        constant,
+        function: {
+          pattern: /(^|[^\\\w])\\?[a-z_](?:[\w\\]*\w)?(?=\s*\()/i,
+          lookbehind: true,
+          inside: {
+            punctuation: /\\/
+          }
+        },
+        property: {
+          pattern: /(->\s*)\w+/,
+          lookbehind: true
+        },
+        number,
+        operator,
+        punctuation
+      };
+      var string_interpolation = {
+        pattern: /\{\$(?:\{(?:\{[^{}]+\}|[^{}]+)\}|[^{}])+\}|(^|[^\\{])\$+(?:\w+(?:\[[^\r\n\[\]]+\]|->\w+)?)/,
+        lookbehind: true,
+        inside: Prism2.languages.php
+      };
+      var string = [
+        {
+          pattern: /<<<'([^']+)'[\r\n](?:.*[\r\n])*?\1;/,
+          alias: "nowdoc-string",
+          greedy: true,
+          inside: {
+            delimiter: {
+              pattern: /^<<<'[^']+'|[a-z_]\w*;$/i,
+              alias: "symbol",
+              inside: {
+                punctuation: /^<<<'?|[';]$/
+              }
+            }
+          }
+        },
+        {
+          pattern: /<<<(?:"([^"]+)"[\r\n](?:.*[\r\n])*?\1;|([a-z_]\w*)[\r\n](?:.*[\r\n])*?\2;)/i,
+          alias: "heredoc-string",
+          greedy: true,
+          inside: {
+            delimiter: {
+              pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i,
+              alias: "symbol",
+              inside: {
+                punctuation: /^<<<"?|[";]$/
+              }
+            },
+            interpolation: string_interpolation
+          }
+        },
+        {
+          pattern: /`(?:\\[\s\S]|[^\\`])*`/,
+          alias: "backtick-quoted-string",
+          greedy: true
+        },
+        {
+          pattern: /'(?:\\[\s\S]|[^\\'])*'/,
+          alias: "single-quoted-string",
+          greedy: true
+        },
+        {
+          pattern: /"(?:\\[\s\S]|[^\\"])*"/,
+          alias: "double-quoted-string",
+          greedy: true,
+          inside: {
+            interpolation: string_interpolation
+          }
+        }
+      ];
+      Prism2.languages.insertBefore("php", "variable", {
+        string,
+        attribute: {
+          pattern: /#\[(?:[^"'\/#]|\/(?![*/])|\/\/.*$|#(?!\[).*$|\/\*(?:[^*]|\*(?!\/))*\*\/|"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*')+\](?=\s*[a-z$#])/im,
+          greedy: true,
+          inside: {
+            "attribute-content": {
+              pattern: /^(#\[)[\s\S]+(?=\]$)/,
+              lookbehind: true,
+              // inside can appear subset of php
+              inside: {
+                comment,
+                string,
+                "attribute-class-name": [
+                  {
+                    pattern: /([^:]|^)\b[a-z_]\w*(?!\\)\b/i,
+                    alias: "class-name",
+                    greedy: true,
+                    lookbehind: true
+                  },
+                  {
+                    pattern: /([^:]|^)(?:\\?\b[a-z_]\w*)+/i,
+                    alias: ["class-name", "class-name-fully-qualified"],
+                    greedy: true,
+                    lookbehind: true,
+                    inside: {
+                      punctuation: /\\/
+                    }
+                  }
+                ],
+                constant,
+                number,
+                operator,
+                punctuation
+              }
+            },
+            delimiter: {
+              pattern: /^#\[|\]$/,
+              alias: "punctuation"
+            }
+          }
+        }
+      });
+      Prism2.hooks.add("before-tokenize", function(env) {
+        if (!/<\?/.test(env.code)) {
+          return;
+        }
+        var phpPattern = /<\?(?:[^"'/#]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|(?:\/\/|#(?!\[))(?:[^?\n\r]|\?(?!>))*(?=$|\?>|[\r\n])|#\[|\/\*(?:[^*]|\*(?!\/))*(?:\*\/|$))*?(?:\?>|$)/g;
+        Prism2.languages["markup-templating"].buildPlaceholders(
+          env,
+          "php",
+          phpPattern
+        );
+      });
+      Prism2.hooks.add("after-tokenize", function(env) {
+        Prism2.languages["markup-templating"].tokenizePlaceholders(env, "php");
+      });
+    })(Prism);
+  }
+  return php_1;
+}
+export {
+  requirePhp as r
+};
+//# sourceMappingURL=php-BBLqus8v.js.map

package/dist/php-BBLqus8v.js.map

@@ -0,0 +1 @@
+{"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-extras-thTLo46T.js

@@ -0,0 +1,59 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requirePhp } from "./php-BBLqus8v.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var phpExtras_1;
+var hasRequiredPhpExtras;
+function requirePhpExtras() {
+  if (hasRequiredPhpExtras) return phpExtras_1;
+  hasRequiredPhpExtras = 1;
+  var refractorPhp = requirePhp();
+  phpExtras_1 = phpExtras2;
+  phpExtras2.displayName = "phpExtras";
+  phpExtras2.aliases = [];
+  function phpExtras2(Prism) {
+    Prism.register(refractorPhp);
+    Prism.languages.insertBefore("php", "variable", {
+      this: {
+        pattern: /\$this\b/,
+        alias: "keyword"
+      },
+      global: /\$(?:GLOBALS|HTTP_RAW_POST_DATA|_(?:COOKIE|ENV|FILES|GET|POST|REQUEST|SERVER|SESSION)|argc|argv|http_response_header|php_errormsg)\b/,
+      scope: {
+        pattern: /\b[\w\\]+::/,
+        inside: {
+          keyword: /\b(?:parent|self|static)\b/,
+          punctuation: /::|\\/
+        }
+      }
+    });
+  }
+  return phpExtras_1;
+}
+var phpExtrasExports = requirePhpExtras();
+const phpExtras = /* @__PURE__ */ getDefaultExportFromCjs(phpExtrasExports);
+const phpExtras$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: phpExtras
+}, [phpExtrasExports]);
+export {
+  phpExtras$1 as p
+};
+//# sourceMappingURL=php-extras-thTLo46T.js.map

package/dist/php-extras-thTLo46T.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"php-extras-thTLo46T.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/php-qWlIPrSK.js

@@ -0,0 +1,31 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requirePhp } from "./php-BBLqus8v.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var phpExports = requirePhp();
+const php = /* @__PURE__ */ getDefaultExportFromCjs(phpExports);
+const php$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: php
+}, [phpExports]);
+export {
+  php$1 as p
+};
+//# sourceMappingURL=php-qWlIPrSK.js.map

package/dist/php-qWlIPrSK.js.map

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

package/dist/phpdoc-Zd1gQNLg.js

@@ -0,0 +1,74 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requirePhp } from "./php-BBLqus8v.js";
+import { r as requireJavadoclike } from "./javadoclike-BdPr_VnG.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var phpdoc_1;
+var hasRequiredPhpdoc;
+function requirePhpdoc() {
+  if (hasRequiredPhpdoc) return phpdoc_1;
+  hasRequiredPhpdoc = 1;
+  var refractorPhp = requirePhp();
+  var refractorJavadoclike = requireJavadoclike();
+  phpdoc_1 = phpdoc2;
+  phpdoc2.displayName = "phpdoc";
+  phpdoc2.aliases = [];
+  function phpdoc2(Prism) {
+    Prism.register(refractorPhp);
+    Prism.register(refractorJavadoclike);
+    (function(Prism2) {
+      var typeExpression = /(?:\b[a-zA-Z]\w*|[|\\[\]])+/.source;
+      Prism2.languages.phpdoc = Prism2.languages.extend("javadoclike", {
+        parameter: {
+          pattern: RegExp(
+            "(@(?:global|param|property(?:-read|-write)?|var)\\s+(?:" + typeExpression + "\\s+)?)\\$\\w+"
+          ),
+          lookbehind: true
+        }
+      });
+      Prism2.languages.insertBefore("phpdoc", "keyword", {
+        "class-name": [
+          {
+            pattern: RegExp(
+              "(@(?:global|package|param|property(?:-read|-write)?|return|subpackage|throws|var)\\s+)" + typeExpression
+            ),
+            lookbehind: true,
+            inside: {
+              keyword: /\b(?:array|bool|boolean|callback|double|false|float|int|integer|mixed|null|object|resource|self|string|true|void)\b/,
+              punctuation: /[|\\[\]()]/
+            }
+          }
+        ]
+      });
+      Prism2.languages.javadoclike.addSupport("php", Prism2.languages.phpdoc);
+    })(Prism);
+  }
+  return phpdoc_1;
+}
+var phpdocExports = requirePhpdoc();
+const phpdoc = /* @__PURE__ */ getDefaultExportFromCjs(phpdocExports);
+const phpdoc$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: phpdoc
+}, [phpdocExports]);
+export {
+  phpdoc$1 as p
+};
+//# sourceMappingURL=phpdoc-Zd1gQNLg.js.map

package/dist/phpdoc-Zd1gQNLg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"phpdoc-Zd1gQNLg.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-oivgB6a0.js

@@ -0,0 +1,61 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireSql } from "./sql-C3TUcweP.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var plsql_1;
+var hasRequiredPlsql;
+function requirePlsql() {
+  if (hasRequiredPlsql) return plsql_1;
+  hasRequiredPlsql = 1;
+  var refractorSql = requireSql();
+  plsql_1 = plsql2;
+  plsql2.displayName = "plsql";
+  plsql2.aliases = [];
+  function plsql2(Prism) {
+    Prism.register(refractorSql);
+    Prism.languages.plsql = Prism.languages.extend("sql", {
+      comment: {
+        pattern: /\/\*[\s\S]*?\*\/|--.*/,
+        greedy: true
+      },
+      // https://docs.oracle.com/en/database/oracle/oracle-database/21/lnpls/plsql-reserved-words-keywords.html
+      keyword: /\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,
+      // https://docs.oracle.com/en/database/oracle/oracle-database/21/lnpls/plsql-language-fundamentals.html#GUID-96A42F7C-7A71-4B90-8255-CA9C8BD9722E
+      operator: /:=?|=>|[<>^~!]=|\.\.|\|\||\*\*|[-+*/%<>=@]/
+    });
+    Prism.languages.insertBefore("plsql", "operator", {
+      label: {
+        pattern: /<<\s*\w+\s*>>/,
+        alias: "symbol"
+      }
+    });
+  }
+  return plsql_1;
+}
+var plsqlExports = requirePlsql();
+const plsql = /* @__PURE__ */ getDefaultExportFromCjs(plsqlExports);
+const plsql$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: plsql
+}, [plsqlExports]);
+export {
+  plsql$1 as p
+};
+//# sourceMappingURL=plsql-oivgB6a0.js.map

package/dist/plsql-oivgB6a0.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plsql-oivgB6a0.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]}