@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/php-C_FrOCG4.js

@@ -0,0 +1,334 @@
+import { r as g } from "./markup-templating-CVTxtFGH.js";
+var n, p;
+function h() {
+  if (p) return n;
+  p = 1;
+  var c = g();
+  n = a, a.displayName = "php", a.aliases = [];
+  function a(i) {
+    i.register(c), function(e) {
+      var r = /\/\*[\s\S]*?\*\/|\/\/.*|#(?!\[).*/, s = [
+        {
+          pattern: /\b(?:false|true)\b/i,
+          alias: "boolean"
+        },
+        {
+          pattern: /(::\s*)\b[a-z_]\w*\b(?!\s*\()/i,
+          greedy: !0,
+          lookbehind: !0
+        },
+        {
+          pattern: /(\b(?:case|const)\s+)\b[a-z_]\w*(?=\s*[;=])/i,
+          greedy: !0,
+          lookbehind: !0
+        },
+        /\b(?:null)\b/i,
+        /\b[A-Z_][A-Z0-9_]*\b(?!\s*\()/
+      ], l = /\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, o = /<?=>|\?\?=?|\.{3}|\??->|[!=]=?=?|::|\*\*=?|--|\+\+|&&|\|\||<<|>>|[?~]|[/^|%*&<>.+-]=?/, u = /[{}\[\](),:;]/;
+      e.languages.php = {
+        delimiter: {
+          pattern: /\?>$|^<\?(?:php(?=\s)|=)?/i,
+          alias: "important"
+        },
+        comment: r,
+        variable: /\$+(?:\w+\b|(?=\{))/,
+        package: {
+          pattern: /(namespace\s+|use\s+(?:function\s+)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+          lookbehind: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        },
+        "class-name-definition": {
+          pattern: /(\b(?:class|enum|interface|trait)\s+)\b[a-z_]\w*(?!\\)\b/i,
+          lookbehind: !0,
+          alias: "class-name"
+        },
+        "function-definition": {
+          pattern: /(\bfunction\s+)[a-z_]\w*(?=\s*\()/i,
+          lookbehind: !0,
+          alias: "function"
+        },
+        keyword: [
+          {
+            pattern: /(\(\s*)\b(?:array|bool|boolean|float|int|integer|object|string)\b(?=\s*\))/i,
+            alias: "type-casting",
+            greedy: !0,
+            lookbehind: !0
+          },
+          {
+            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: !0,
+            lookbehind: !0
+          },
+          {
+            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: !0,
+            lookbehind: !0
+          },
+          {
+            pattern: /\b(?:array(?!\s*\()|bool|float|int|iterable|mixed|object|string|void)\b/i,
+            alias: "type-declaration",
+            greedy: !0
+          },
+          {
+            pattern: /(\|\s*)(?:false|null)\b|\b(?:false|null)(?=\s*\|)/i,
+            alias: "type-declaration",
+            greedy: !0,
+            lookbehind: !0
+          },
+          {
+            pattern: /\b(?:parent|self|static)(?=\s*::)/i,
+            alias: "static-context",
+            greedy: !0
+          },
+          {
+            // yield from
+            pattern: /(\byield\s+)from\b/i,
+            lookbehind: !0
+          },
+          // `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: !0
+          }
+        ],
+        "argument-name": {
+          pattern: /([(,]\s+)\b[a-z_]\w*(?=\s*:(?!:))/i,
+          lookbehind: !0
+        },
+        "class-name": [
+          {
+            pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self|\s+static))\s+|\bcatch\s*\()\b[a-z_]\w*(?!\\)\b/i,
+            greedy: !0,
+            lookbehind: !0
+          },
+          {
+            pattern: /(\|\s*)\b[a-z_]\w*(?!\\)\b/i,
+            greedy: !0,
+            lookbehind: !0
+          },
+          {
+            pattern: /\b[a-z_]\w*(?!\\)\b(?=\s*\|)/i,
+            greedy: !0
+          },
+          {
+            pattern: /(\|\s*)(?:\\?\b[a-z_]\w*)+\b/i,
+            alias: "class-name-fully-qualified",
+            greedy: !0,
+            lookbehind: !0,
+            inside: {
+              punctuation: /\\/
+            }
+          },
+          {
+            pattern: /(?:\\?\b[a-z_]\w*)+\b(?=\s*\|)/i,
+            alias: "class-name-fully-qualified",
+            greedy: !0,
+            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: !0,
+            lookbehind: !0,
+            inside: {
+              punctuation: /\\/
+            }
+          },
+          {
+            pattern: /\b[a-z_]\w*(?=\s*\$)/i,
+            alias: "type-declaration",
+            greedy: !0
+          },
+          {
+            pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
+            alias: ["class-name-fully-qualified", "type-declaration"],
+            greedy: !0,
+            inside: {
+              punctuation: /\\/
+            }
+          },
+          {
+            pattern: /\b[a-z_]\w*(?=\s*::)/i,
+            alias: "static-context",
+            greedy: !0
+          },
+          {
+            pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*::)/i,
+            alias: ["class-name-fully-qualified", "static-context"],
+            greedy: !0,
+            inside: {
+              punctuation: /\\/
+            }
+          },
+          {
+            pattern: /([(,?]\s*)[a-z_]\w*(?=\s*\$)/i,
+            alias: "type-hint",
+            greedy: !0,
+            lookbehind: !0
+          },
+          {
+            pattern: /([(,?]\s*)(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
+            alias: ["class-name-fully-qualified", "type-hint"],
+            greedy: !0,
+            lookbehind: !0,
+            inside: {
+              punctuation: /\\/
+            }
+          },
+          {
+            pattern: /(\)\s*:\s*(?:\?\s*)?)\b[a-z_]\w*(?!\\)\b/i,
+            alias: "return-type",
+            greedy: !0,
+            lookbehind: !0
+          },
+          {
+            pattern: /(\)\s*:\s*(?:\?\s*)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+            alias: ["class-name-fully-qualified", "return-type"],
+            greedy: !0,
+            lookbehind: !0,
+            inside: {
+              punctuation: /\\/
+            }
+          }
+        ],
+        constant: s,
+        function: {
+          pattern: /(^|[^\\\w])\\?[a-z_](?:[\w\\]*\w)?(?=\s*\()/i,
+          lookbehind: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        },
+        property: {
+          pattern: /(->\s*)\w+/,
+          lookbehind: !0
+        },
+        number: l,
+        operator: o,
+        punctuation: u
+      };
+      var d = {
+        pattern: /\{\$(?:\{(?:\{[^{}]+\}|[^{}]+)\}|[^{}])+\}|(^|[^\\{])\$+(?:\w+(?:\[[^\r\n\[\]]+\]|->\w+)?)/,
+        lookbehind: !0,
+        inside: e.languages.php
+      }, b = [
+        {
+          pattern: /<<<'([^']+)'[\r\n](?:.*[\r\n])*?\1;/,
+          alias: "nowdoc-string",
+          greedy: !0,
+          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: !0,
+          inside: {
+            delimiter: {
+              pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i,
+              alias: "symbol",
+              inside: {
+                punctuation: /^<<<"?|[";]$/
+              }
+            },
+            interpolation: d
+          }
+        },
+        {
+          pattern: /`(?:\\[\s\S]|[^\\`])*`/,
+          alias: "backtick-quoted-string",
+          greedy: !0
+        },
+        {
+          pattern: /'(?:\\[\s\S]|[^\\'])*'/,
+          alias: "single-quoted-string",
+          greedy: !0
+        },
+        {
+          pattern: /"(?:\\[\s\S]|[^\\"])*"/,
+          alias: "double-quoted-string",
+          greedy: !0,
+          inside: {
+            interpolation: d
+          }
+        }
+      ];
+      e.languages.insertBefore("php", "variable", {
+        string: b,
+        attribute: {
+          pattern: /#\[(?:[^"'\/#]|\/(?![*/])|\/\/.*$|#(?!\[).*$|\/\*(?:[^*]|\*(?!\/))*\*\/|"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*')+\](?=\s*[a-z$#])/im,
+          greedy: !0,
+          inside: {
+            "attribute-content": {
+              pattern: /^(#\[)[\s\S]+(?=\]$)/,
+              lookbehind: !0,
+              // inside can appear subset of php
+              inside: {
+                comment: r,
+                string: b,
+                "attribute-class-name": [
+                  {
+                    pattern: /([^:]|^)\b[a-z_]\w*(?!\\)\b/i,
+                    alias: "class-name",
+                    greedy: !0,
+                    lookbehind: !0
+                  },
+                  {
+                    pattern: /([^:]|^)(?:\\?\b[a-z_]\w*)+/i,
+                    alias: ["class-name", "class-name-fully-qualified"],
+                    greedy: !0,
+                    lookbehind: !0,
+                    inside: {
+                      punctuation: /\\/
+                    }
+                  }
+                ],
+                constant: s,
+                number: l,
+                operator: o,
+                punctuation: u
+              }
+            },
+            delimiter: {
+              pattern: /^#\[|\]$/,
+              alias: "punctuation"
+            }
+          }
+        }
+      }), e.hooks.add("before-tokenize", function(t) {
+        if (/<\?/.test(t.code)) {
+          var f = /<\?(?:[^"'/#]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|(?:\/\/|#(?!\[))(?:[^?\n\r]|\?(?!>))*(?=$|\?>|[\r\n])|#\[|\/\*(?:[^*]|\*(?!\/))*(?:\*\/|$))*?(?:\?>|$)/g;
+          e.languages["markup-templating"].buildPlaceholders(
+            t,
+            "php",
+            f
+          );
+        }
+      }), e.hooks.add("after-tokenize", function(t) {
+        e.languages["markup-templating"].tokenizePlaceholders(t, "php");
+      });
+    }(i);
+  }
+  return n;
+}
+export {
+  h as r
+};

package/dist/php-e7f7GtZ8.js

@@ -0,0 +1,26 @@
+import { g as f } from "./index-Sj89RFCY.js";
+import { r as s } from "./php-C_FrOCG4.js";
+function i(t, n) {
+  for (var o = 0; o < n.length; o++) {
+    const e = n[o];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const r in e)
+        if (r !== "default" && !(r in t)) {
+          const p = Object.getOwnPropertyDescriptor(e, r);
+          p && Object.defineProperty(t, r, p.get ? p : {
+            enumerable: !0,
+            get: () => e[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var a = s();
+const c = /* @__PURE__ */ f(a), l = /* @__PURE__ */ i({
+  __proto__: null,
+  default: c
+}, [a]);
+export {
+  l as p
+};

package/dist/php-extras-ATZDccPm.js

@@ -0,0 +1,50 @@
+import { g as f } from "./index-Sj89RFCY.js";
+import { r as u } from "./php-C_FrOCG4.js";
+function c(t, r) {
+  for (var e = 0; e < r.length; e++) {
+    const a = r[e];
+    if (typeof a != "string" && !Array.isArray(a)) {
+      for (const p in a)
+        if (p !== "default" && !(p in t)) {
+          const s = Object.getOwnPropertyDescriptor(a, p);
+          s && Object.defineProperty(t, p, s.get ? s : {
+            enumerable: !0,
+            get: () => a[p]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var o, n;
+function E() {
+  if (n) return o;
+  n = 1;
+  var t = u();
+  o = r, r.displayName = "phpExtras", r.aliases = [];
+  function r(e) {
+    e.register(t), e.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 o;
+}
+var i = E();
+const h = /* @__PURE__ */ f(i), b = /* @__PURE__ */ c({
+  __proto__: null,
+  default: h
+}, [i]);
+export {
+  b as p
+};

package/dist/phpdoc-uba1O-5-.js

@@ -0,0 +1,61 @@
+import { g as i } from "./index-Sj89RFCY.js";
+import { r as s } from "./php-C_FrOCG4.js";
+import { r as d } from "./javadoclike-CHbTYI14.js";
+function u(t, p) {
+  for (var a = 0; a < p.length; a++) {
+    const r = p[a];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const e in r)
+        if (e !== "default" && !(e in t)) {
+          const o = Object.getOwnPropertyDescriptor(r, e);
+          o && Object.defineProperty(t, e, o.get ? o : {
+            enumerable: !0,
+            get: () => r[e]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var n, c;
+function g() {
+  if (c) return n;
+  c = 1;
+  var t = s(), p = d();
+  n = a, a.displayName = "phpdoc", a.aliases = [];
+  function a(r) {
+    r.register(t), r.register(p), function(e) {
+      var o = /(?:\b[a-zA-Z]\w*|[|\\[\]])+/.source;
+      e.languages.phpdoc = e.languages.extend("javadoclike", {
+        parameter: {
+          pattern: RegExp(
+            "(@(?:global|param|property(?:-read|-write)?|var)\\s+(?:" + o + "\\s+)?)\\$\\w+"
+          ),
+          lookbehind: !0
+        }
+      }), e.languages.insertBefore("phpdoc", "keyword", {
+        "class-name": [
+          {
+            pattern: RegExp(
+              "(@(?:global|package|param|property(?:-read|-write)?|return|subpackage|throws|var)\\s+)" + o
+            ),
+            lookbehind: !0,
+            inside: {
+              keyword: /\b(?:array|bool|boolean|callback|double|false|float|int|integer|mixed|null|object|resource|self|string|true|void)\b/,
+              punctuation: /[|\\[\]()]/
+            }
+          }
+        ]
+      }), e.languages.javadoclike.addSupport("php", e.languages.phpdoc);
+    }(r);
+  }
+  return n;
+}
+var l = g();
+const f = /* @__PURE__ */ i(l), y = /* @__PURE__ */ u({
+  __proto__: null,
+  default: f
+}, [l]);
+export {
+  y as p
+};

package/dist/plsql-BLNilzVM.js

@@ -0,0 +1,51 @@
+import { g as C } from "./index-Sj89RFCY.js";
+import { r as D } from "./sql-qhcRp-Km.js";
+function U(T, A) {
+  for (var E = 0; E < A.length; E++) {
+    const I = A[E];
+    if (typeof I != "string" && !Array.isArray(I)) {
+      for (const R in I)
+        if (R !== "default" && !(R in T)) {
+          const N = Object.getOwnPropertyDescriptor(I, R);
+          N && Object.defineProperty(T, R, N.get ? N : {
+            enumerable: !0,
+            get: () => I[R]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(T, Symbol.toStringTag, { value: "Module" }));
+}
+var O, S;
+function e() {
+  if (S) return O;
+  S = 1;
+  var T = D();
+  O = A, A.displayName = "plsql", A.aliases = [];
+  function A(E) {
+    E.register(T), E.languages.plsql = E.languages.extend("sql", {
+      comment: {
+        pattern: /\/\*[\s\S]*?\*\/|--.*/,
+        greedy: !0
+      },
+      // 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: /:=?|=>|[<>^~!]=|\.\.|\|\||\*\*|[-+*/%<>=@]/
+    }), E.languages.insertBefore("plsql", "operator", {
+      label: {
+        pattern: /<<\s*\w+\s*>>/,
+        alias: "symbol"
+      }
+    });
+  }
+  return O;
+}
+var L = e();
+const M = /* @__PURE__ */ C(L), P = /* @__PURE__ */ U({
+  __proto__: null,
+  default: M
+}, [L]);
+export {
+  P as p
+};

package/dist/powerquery-CddEWH0P.js

@@ -0,0 +1,83 @@
+import { g as d } from "./index-Sj89RFCY.js";
+function s(t, e) {
+  for (var o = 0; o < e.length; o++) {
+    const r = e[o];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const n in r)
+        if (n !== "default" && !(n in t)) {
+          const a = Object.getOwnPropertyDescriptor(r, n);
+          a && Object.defineProperty(t, n, a.get ? a : {
+            enumerable: !0,
+            get: () => r[n]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var i, u;
+function l() {
+  if (u) return i;
+  u = 1, i = t, t.displayName = "powerquery", t.aliases = [];
+  function t(e) {
+    e.languages.powerquery = {
+      comment: {
+        pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      "quoted-identifier": {
+        pattern: /#"(?:[^"\r\n]|"")*"(?!")/,
+        greedy: !0
+      },
+      string: {
+        pattern: /(?:#!)?"(?:[^"\r\n]|"")*"(?!")/,
+        greedy: !0
+      },
+      constant: [
+        /\bDay\.(?:Friday|Monday|Saturday|Sunday|Thursday|Tuesday|Wednesday)\b/,
+        /\bTraceLevel\.(?:Critical|Error|Information|Verbose|Warning)\b/,
+        /\bOccurrence\.(?:All|First|Last)\b/,
+        /\bOrder\.(?:Ascending|Descending)\b/,
+        /\bRoundingMode\.(?:AwayFromZero|Down|ToEven|TowardZero|Up)\b/,
+        /\bMissingField\.(?:Error|Ignore|UseNull)\b/,
+        /\bQuoteStyle\.(?:Csv|None)\b/,
+        /\bJoinKind\.(?:FullOuter|Inner|LeftAnti|LeftOuter|RightAnti|RightOuter)\b/,
+        /\bGroupKind\.(?:Global|Local)\b/,
+        /\bExtraValues\.(?:Error|Ignore|List)\b/,
+        /\bJoinAlgorithm\.(?:Dynamic|LeftHash|LeftIndex|PairwiseHash|RightHash|RightIndex|SortMerge)\b/,
+        /\bJoinSide\.(?:Left|Right)\b/,
+        /\bPrecision\.(?:Decimal|Double)\b/,
+        /\bRelativePosition\.From(?:End|Start)\b/,
+        /\bTextEncoding\.(?:Ascii|BigEndianUnicode|Unicode|Utf16|Utf8|Windows)\b/,
+        /\b(?:Any|Binary|Date|DateTime|DateTimeZone|Duration|Function|Int16|Int32|Int64|Int8|List|Logical|None|Number|Record|Table|Text|Time)\.Type\b/,
+        /\bnull\b/
+      ],
+      boolean: /\b(?:false|true)\b/,
+      keyword: /\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/,
+      function: {
+        pattern: /(^|[^#\w.])[a-z_][\w.]*(?=\s*\()/i,
+        lookbehind: !0
+      },
+      "data-type": {
+        pattern: /\b(?:any|anynonnull|binary|date|datetime|datetimezone|duration|function|list|logical|none|number|record|table|text|time)\b/,
+        alias: "class-name"
+      },
+      number: {
+        pattern: /\b0x[\da-f]+\b|(?:[+-]?(?:\b\d+\.)?\b\d+|[+-]\.\d+|(^|[^.])\B\.\d+)(?:e[+-]?\d+)?\b/i,
+        lookbehind: !0
+      },
+      operator: /[-+*\/&?@^]|<(?:=>?|>)?|>=?|=>?|\.\.\.?/,
+      punctuation: /[,;\[\](){}]/
+    }, e.languages.pq = e.languages.powerquery, e.languages.mscript = e.languages.powerquery;
+  }
+  return i;
+}
+var b = l();
+const y = /* @__PURE__ */ d(b), g = /* @__PURE__ */ s({
+  __proto__: null,
+  default: y
+}, [b]);
+export {
+  g as p
+};