@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/wren-C3O5Qi9Z.js

@@ -0,0 +1,131 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.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 wren_1;
+var hasRequiredWren;
+function requireWren() {
+  if (hasRequiredWren) return wren_1;
+  hasRequiredWren = 1;
+  wren_1 = wren2;
+  wren2.displayName = "wren";
+  wren2.aliases = [];
+  function wren2(Prism) {
+    Prism.languages.wren = {
+      // Multiline comments in Wren can have nested multiline comments
+      // Comments: // and /* */
+      comment: [
+        {
+          // support 3 levels of nesting
+          // regex: \/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\/
+          pattern: /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|\/\*(?:[^*/]|\*(?!\/)|\/(?!\*))*\*\/)*\*\/)*\*\//,
+          greedy: true
+        },
+        {
+          pattern: /(^|[^\\:])\/\/.*/,
+          lookbehind: true,
+          greedy: true
+        }
+      ],
+      // Triple quoted strings are multiline but cannot have interpolation (raw strings)
+      // Based on prism-python.js
+      "triple-quoted-string": {
+        pattern: /"""[\s\S]*?"""/,
+        greedy: true,
+        alias: "string"
+      },
+      // see below
+      "string-literal": null,
+      // #!/usr/bin/env wren on the first line
+      hashbang: {
+        pattern: /^#!\/.+/,
+        greedy: true,
+        alias: "comment"
+      },
+      // Attributes are special keywords to add meta data to classes
+      attribute: {
+        // #! attributes are stored in class properties
+        // #!myvar = true
+        // #attributes are not stored and dismissed at compilation
+        pattern: /#!?[ \t\u3000]*\w+/,
+        alias: "keyword"
+      },
+      "class-name": [
+        {
+          // class definition
+          // class Meta {}
+          pattern: /(\bclass\s+)\w+/,
+          lookbehind: true
+        },
+        // A class must always start with an uppercase.
+        // File.read
+        /\b[A-Z][a-z\d_]*\b/
+      ],
+      // A constant can be a variable, class, property or method. Just named in all uppercase letters
+      constant: /\b[A-Z][A-Z\d_]*\b/,
+      null: {
+        pattern: /\bnull\b/,
+        alias: "keyword"
+      },
+      keyword: /\b(?:as|break|class|construct|continue|else|for|foreign|if|import|in|is|return|static|super|this|var|while)\b/,
+      boolean: /\b(?:false|true)\b/,
+      number: /\b(?:0x[\da-f]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/i,
+      // Functions can be Class.method()
+      function: /\b[a-z_]\w*(?=\s*[({])/i,
+      operator: /<<|>>|[=!<>]=?|&&|\|\||[-+*/%~^&|?:]|\.{2,3}/,
+      punctuation: /[\[\](){}.,;]/
+    };
+    Prism.languages.wren["string-literal"] = {
+      // A single quote string is multiline and can have interpolation (similar to JS backticks ``)
+      pattern: /(^|[^\\"])"(?:[^\\"%]|\\[\s\S]|%(?!\()|%\((?:[^()]|\((?:[^()]|\([^)]*\))*\))*\))*"/,
+      lookbehind: true,
+      greedy: true,
+      inside: {
+        interpolation: {
+          // "%(interpolation)"
+          pattern: /((?:^|[^\\])(?:\\{2})*)%\((?:[^()]|\((?:[^()]|\([^)]*\))*\))*\)/,
+          lookbehind: true,
+          inside: {
+            expression: {
+              pattern: /^(%\()[\s\S]+(?=\)$)/,
+              lookbehind: true,
+              inside: Prism.languages.wren
+            },
+            "interpolation-punctuation": {
+              pattern: /^%\(|\)$/,
+              alias: "punctuation"
+            }
+          }
+        },
+        string: /[\s\S]+/
+      }
+    };
+  }
+  return wren_1;
+}
+var wrenExports = requireWren();
+const wren = /* @__PURE__ */ getDefaultExportFromCjs(wrenExports);
+const wren$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: wren
+}, [wrenExports]);
+export {
+  wren$1 as w
+};
+//# sourceMappingURL=wren-C3O5Qi9Z.js.map

package/dist/wren-C3O5Qi9Z.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wren-C3O5Qi9Z.js","sources":["../node_modules/refractor/lang/wren.js"],"sourcesContent":["'use strict'\n\nmodule.exports = wren\nwren.displayName = 'wren'\nwren.aliases = []\nfunction wren(Prism) {\n  // https://wren.io/\n  Prism.languages.wren = {\n    // Multiline comments in Wren can have nested multiline comments\n    // Comments: // and /* */\n    comment: [\n      {\n        // support 3 levels of nesting\n        // regex: \\/\\*(?:[^*/]|\\*(?!\\/)|\\/(?!\\*)|<self>)*\\*\\/\n        pattern:\n          /\\/\\*(?:[^*/]|\\*(?!\\/)|\\/(?!\\*)|\\/\\*(?:[^*/]|\\*(?!\\/)|\\/(?!\\*)|\\/\\*(?:[^*/]|\\*(?!\\/)|\\/(?!\\*))*\\*\\/)*\\*\\/)*\\*\\//,\n        greedy: true\n      },\n      {\n        pattern: /(^|[^\\\\:])\\/\\/.*/,\n        lookbehind: true,\n        greedy: true\n      }\n    ],\n    // Triple quoted strings are multiline but cannot have interpolation (raw strings)\n    // Based on prism-python.js\n    'triple-quoted-string': {\n      pattern: /\"\"\"[\\s\\S]*?\"\"\"/,\n      greedy: true,\n      alias: 'string'\n    },\n    // see below\n    'string-literal': null,\n    // #!/usr/bin/env wren on the first line\n    hashbang: {\n      pattern: /^#!\\/.+/,\n      greedy: true,\n      alias: 'comment'\n    },\n    // Attributes are special keywords to add meta data to classes\n    attribute: {\n      // #! attributes are stored in class properties\n      // #!myvar = true\n      // #attributes are not stored and dismissed at compilation\n      pattern: /#!?[ \\t\\u3000]*\\w+/,\n      alias: 'keyword'\n    },\n    'class-name': [\n      {\n        // class definition\n        // class Meta {}\n        pattern: /(\\bclass\\s+)\\w+/,\n        lookbehind: true\n      }, // A class must always start with an uppercase.\n      // File.read\n      /\\b[A-Z][a-z\\d_]*\\b/\n    ],\n    // A constant can be a variable, class, property or method. Just named in all uppercase letters\n    constant: /\\b[A-Z][A-Z\\d_]*\\b/,\n    null: {\n      pattern: /\\bnull\\b/,\n      alias: 'keyword'\n    },\n    keyword:\n      /\\b(?:as|break|class|construct|continue|else|for|foreign|if|import|in|is|return|static|super|this|var|while)\\b/,\n    boolean: /\\b(?:false|true)\\b/,\n    number: /\\b(?:0x[\\da-f]+|\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?)\\b/i,\n    // Functions can be Class.method()\n    function: /\\b[a-z_]\\w*(?=\\s*[({])/i,\n    operator: /<<|>>|[=!<>]=?|&&|\\|\\||[-+*/%~^&|?:]|\\.{2,3}/,\n    punctuation: /[\\[\\](){}.,;]/\n  }\n  Prism.languages.wren['string-literal'] = {\n    // A single quote string is multiline and can have interpolation (similar to JS backticks ``)\n    pattern:\n      /(^|[^\\\\\"])\"(?:[^\\\\\"%]|\\\\[\\s\\S]|%(?!\\()|%\\((?:[^()]|\\((?:[^()]|\\([^)]*\\))*\\))*\\))*\"/,\n    lookbehind: true,\n    greedy: true,\n    inside: {\n      interpolation: {\n        // \"%(interpolation)\"\n        pattern:\n          /((?:^|[^\\\\])(?:\\\\{2})*)%\\((?:[^()]|\\((?:[^()]|\\([^)]*\\))*\\))*\\)/,\n        lookbehind: true,\n        inside: {\n          expression: {\n            pattern: /^(%\\()[\\s\\S]+(?=\\)$)/,\n            lookbehind: true,\n            inside: Prism.languages.wren\n          },\n          'interpolation-punctuation': {\n            pattern: /^%\\(|\\)$/,\n            alias: 'punctuation'\n          }\n        }\n      },\n      string: /[\\s\\S]+/\n    }\n  }\n}\n"],"names":["wren"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AAEnB,UAAM,UAAU,OAAO;AAAA;AAAA;AAAA,MAGrB,SAAS;AAAA,QACP;AAAA;AAAA;AAAA,UAGE,SACE;AAAA,UACF,QAAQ;AAAA;QAEV;AAAA,UACE,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA;;;;MAKZ,wBAAwB;AAAA,QACtB,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,OAAO;AAAA;;MAGT,kBAAkB;AAAA;AAAA,MAElB,UAAU;AAAA,QACR,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,OAAO;AAAA;;MAGT,WAAW;AAAA;AAAA;AAAA;AAAA,QAIT,SAAS;AAAA,QACT,OAAO;AAAA;MAET,cAAc;AAAA,QACZ;AAAA;AAAA;AAAA,UAGE,SAAS;AAAA,UACT,YAAY;AAAA;;;QAGd;AAAA;;MAGF,UAAU;AAAA,MACV,MAAM;AAAA,QACJ,SAAS;AAAA,QACT,OAAO;AAAA;MAET,SACE;AAAA,MACF,SAAS;AAAA,MACT,QAAQ;AAAA;AAAA,MAER,UAAU;AAAA,MACV,UAAU;AAAA,MACV,aAAa;AAAA;AAEf,UAAM,UAAU,KAAK,gBAAgB,IAAI;AAAA;AAAA,MAEvC,SACE;AAAA,MACF,YAAY;AAAA,MACZ,QAAQ;AAAA,MACR,QAAQ;AAAA,QACN,eAAe;AAAA;AAAA,UAEb,SACE;AAAA,UACF,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN,YAAY;AAAA,cACV,SAAS;AAAA,cACT,YAAY;AAAA,cACZ,QAAQ,MAAM,UAAU;AAAA;YAE1B,6BAA6B;AAAA,cAC3B,SAAS;AAAA,cACT,OAAO;AAAA;;;QAIb,QAAQ;AAAA;;EAGd;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/xeora-Bxq5guzy.js

@@ -0,0 +1,158 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.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 xeora_1;
+var hasRequiredXeora;
+function requireXeora() {
+  if (hasRequiredXeora) return xeora_1;
+  hasRequiredXeora = 1;
+  xeora_1 = xeora2;
+  xeora2.displayName = "xeora";
+  xeora2.aliases = ["xeoracube"];
+  function xeora2(Prism) {
+    (function(Prism2) {
+      Prism2.languages.xeora = Prism2.languages.extend("markup", {
+        constant: {
+          pattern: /\$(?:DomainContents|PageRenderDuration)\$/,
+          inside: {
+            punctuation: {
+              pattern: /\$/
+            }
+          }
+        },
+        variable: {
+          pattern: /\$@?(?:#+|[-+*~=^])?[\w.]+\$/,
+          inside: {
+            punctuation: {
+              pattern: /[$.]/
+            },
+            operator: {
+              pattern: /#+|[-+*~=^@]/
+            }
+          }
+        },
+        "function-inline": {
+          pattern: /\$F:[-\w.]+\?[-\w.]+(?:,(?:(?:@[-#]*\w+\.[\w+.]\.*)*\|)*(?:(?:[\w+]|[-#*.~^]+[\w+]|=\S)(?:[^$=]|=+[^=])*=*|(?:@[-#]*\w+\.[\w+.]\.*)+(?:(?:[\w+]|[-#*~^][-#*.~^]*[\w+]|=\S)(?:[^$=]|=+[^=])*=*)?)?)?\$/,
+          inside: {
+            variable: {
+              pattern: /(?:[,|])@?(?:#+|[-+*~=^])?[\w.]+/,
+              inside: {
+                punctuation: {
+                  pattern: /[,.|]/
+                },
+                operator: {
+                  pattern: /#+|[-+*~=^@]/
+                }
+              }
+            },
+            punctuation: {
+              pattern: /\$\w:|[$:?.,|]/
+            }
+          },
+          alias: "function"
+        },
+        "function-block": {
+          pattern: /\$XF:\{[-\w.]+\?[-\w.]+(?:,(?:(?:@[-#]*\w+\.[\w+.]\.*)*\|)*(?:(?:[\w+]|[-#*.~^]+[\w+]|=\S)(?:[^$=]|=+[^=])*=*|(?:@[-#]*\w+\.[\w+.]\.*)+(?:(?:[\w+]|[-#*~^][-#*.~^]*[\w+]|=\S)(?:[^$=]|=+[^=])*=*)?)?)?\}:XF\$/,
+          inside: {
+            punctuation: {
+              pattern: /[$:{}?.,|]/
+            }
+          },
+          alias: "function"
+        },
+        "directive-inline": {
+          pattern: /\$\w(?:#\d+\+?)?(?:\[[-\w.]+\])?:[-\/\w.]+\$/,
+          inside: {
+            punctuation: {
+              pattern: /\$(?:\w:|C(?:\[|#\d))?|[:{[\]]/,
+              inside: {
+                tag: {
+                  pattern: /#\d/
+                }
+              }
+            }
+          },
+          alias: "function"
+        },
+        "directive-block-open": {
+          pattern: /\$\w+:\{|\$\w(?:#\d+\+?)?(?:\[[-\w.]+\])?:[-\w.]+:\{(?:![A-Z]+)?/,
+          inside: {
+            punctuation: {
+              pattern: /\$(?:\w:|C(?:\[|#\d))?|[:{[\]]/,
+              inside: {
+                tag: {
+                  pattern: /#\d/
+                }
+              }
+            },
+            attribute: {
+              pattern: /![A-Z]+$/,
+              inside: {
+                punctuation: {
+                  pattern: /!/
+                }
+              },
+              alias: "keyword"
+            }
+          },
+          alias: "function"
+        },
+        "directive-block-separator": {
+          pattern: /\}:[-\w.]+:\{/,
+          inside: {
+            punctuation: {
+              pattern: /[:{}]/
+            }
+          },
+          alias: "function"
+        },
+        "directive-block-close": {
+          pattern: /\}:[-\w.]+\$/,
+          inside: {
+            punctuation: {
+              pattern: /[:{}$]/
+            }
+          },
+          alias: "function"
+        }
+      });
+      Prism2.languages.insertBefore(
+        "inside",
+        "punctuation",
+        {
+          variable: Prism2.languages.xeora["function-inline"].inside["variable"]
+        },
+        Prism2.languages.xeora["function-block"]
+      );
+      Prism2.languages.xeoracube = Prism2.languages.xeora;
+    })(Prism);
+  }
+  return xeora_1;
+}
+var xeoraExports = requireXeora();
+const xeora = /* @__PURE__ */ getDefaultExportFromCjs(xeoraExports);
+const xeora$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: xeora
+}, [xeoraExports]);
+export {
+  xeora$1 as x
+};
+//# sourceMappingURL=xeora-Bxq5guzy.js.map

package/dist/xeora-Bxq5guzy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xeora-Bxq5guzy.js","sources":["../node_modules/refractor/lang/xeora.js"],"sourcesContent":["'use strict'\n\nmodule.exports = xeora\nxeora.displayName = 'xeora'\nxeora.aliases = ['xeoracube']\nfunction xeora(Prism) {\n  ;(function (Prism) {\n    Prism.languages.xeora = Prism.languages.extend('markup', {\n      constant: {\n        pattern: /\\$(?:DomainContents|PageRenderDuration)\\$/,\n        inside: {\n          punctuation: {\n            pattern: /\\$/\n          }\n        }\n      },\n      variable: {\n        pattern: /\\$@?(?:#+|[-+*~=^])?[\\w.]+\\$/,\n        inside: {\n          punctuation: {\n            pattern: /[$.]/\n          },\n          operator: {\n            pattern: /#+|[-+*~=^@]/\n          }\n        }\n      },\n      'function-inline': {\n        pattern:\n          /\\$F:[-\\w.]+\\?[-\\w.]+(?:,(?:(?:@[-#]*\\w+\\.[\\w+.]\\.*)*\\|)*(?:(?:[\\w+]|[-#*.~^]+[\\w+]|=\\S)(?:[^$=]|=+[^=])*=*|(?:@[-#]*\\w+\\.[\\w+.]\\.*)+(?:(?:[\\w+]|[-#*~^][-#*.~^]*[\\w+]|=\\S)(?:[^$=]|=+[^=])*=*)?)?)?\\$/,\n        inside: {\n          variable: {\n            pattern: /(?:[,|])@?(?:#+|[-+*~=^])?[\\w.]+/,\n            inside: {\n              punctuation: {\n                pattern: /[,.|]/\n              },\n              operator: {\n                pattern: /#+|[-+*~=^@]/\n              }\n            }\n          },\n          punctuation: {\n            pattern: /\\$\\w:|[$:?.,|]/\n          }\n        },\n        alias: 'function'\n      },\n      'function-block': {\n        pattern:\n          /\\$XF:\\{[-\\w.]+\\?[-\\w.]+(?:,(?:(?:@[-#]*\\w+\\.[\\w+.]\\.*)*\\|)*(?:(?:[\\w+]|[-#*.~^]+[\\w+]|=\\S)(?:[^$=]|=+[^=])*=*|(?:@[-#]*\\w+\\.[\\w+.]\\.*)+(?:(?:[\\w+]|[-#*~^][-#*.~^]*[\\w+]|=\\S)(?:[^$=]|=+[^=])*=*)?)?)?\\}:XF\\$/,\n        inside: {\n          punctuation: {\n            pattern: /[$:{}?.,|]/\n          }\n        },\n        alias: 'function'\n      },\n      'directive-inline': {\n        pattern: /\\$\\w(?:#\\d+\\+?)?(?:\\[[-\\w.]+\\])?:[-\\/\\w.]+\\$/,\n        inside: {\n          punctuation: {\n            pattern: /\\$(?:\\w:|C(?:\\[|#\\d))?|[:{[\\]]/,\n            inside: {\n              tag: {\n                pattern: /#\\d/\n              }\n            }\n          }\n        },\n        alias: 'function'\n      },\n      'directive-block-open': {\n        pattern:\n          /\\$\\w+:\\{|\\$\\w(?:#\\d+\\+?)?(?:\\[[-\\w.]+\\])?:[-\\w.]+:\\{(?:![A-Z]+)?/,\n        inside: {\n          punctuation: {\n            pattern: /\\$(?:\\w:|C(?:\\[|#\\d))?|[:{[\\]]/,\n            inside: {\n              tag: {\n                pattern: /#\\d/\n              }\n            }\n          },\n          attribute: {\n            pattern: /![A-Z]+$/,\n            inside: {\n              punctuation: {\n                pattern: /!/\n              }\n            },\n            alias: 'keyword'\n          }\n        },\n        alias: 'function'\n      },\n      'directive-block-separator': {\n        pattern: /\\}:[-\\w.]+:\\{/,\n        inside: {\n          punctuation: {\n            pattern: /[:{}]/\n          }\n        },\n        alias: 'function'\n      },\n      'directive-block-close': {\n        pattern: /\\}:[-\\w.]+\\$/,\n        inside: {\n          punctuation: {\n            pattern: /[:{}$]/\n          }\n        },\n        alias: 'function'\n      }\n    })\n    Prism.languages.insertBefore(\n      'inside',\n      'punctuation',\n      {\n        variable: Prism.languages.xeora['function-inline'].inside['variable']\n      },\n      Prism.languages.xeora['function-block']\n    )\n    Prism.languages.xeoracube = Prism.languages.xeora\n  })(Prism)\n}\n"],"names":["xeora","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,YAAiBA;AACjB,EAAAA,OAAM,cAAc;AACpB,EAAAA,OAAM,UAAU,CAAC,WAAW;AAC5B,WAASA,OAAM,OAAO;AACnB,KAAC,SAAUC,QAAO;AACjB,MAAAA,OAAM,UAAU,QAAQA,OAAM,UAAU,OAAO,UAAU;AAAA,QACvD,UAAU;AAAA,UACR,SAAS;AAAA,UACT,QAAQ;AAAA,YACN,aAAa;AAAA,cACX,SAAS;AAAA;;;QAIf,UAAU;AAAA,UACR,SAAS;AAAA,UACT,QAAQ;AAAA,YACN,aAAa;AAAA,cACX,SAAS;AAAA;YAEX,UAAU;AAAA,cACR,SAAS;AAAA;;;QAIf,mBAAmB;AAAA,UACjB,SACE;AAAA,UACF,QAAQ;AAAA,YACN,UAAU;AAAA,cACR,SAAS;AAAA,cACT,QAAQ;AAAA,gBACN,aAAa;AAAA,kBACX,SAAS;AAAA;gBAEX,UAAU;AAAA,kBACR,SAAS;AAAA;;;YAIf,aAAa;AAAA,cACX,SAAS;AAAA;;UAGb,OAAO;AAAA;QAET,kBAAkB;AAAA,UAChB,SACE;AAAA,UACF,QAAQ;AAAA,YACN,aAAa;AAAA,cACX,SAAS;AAAA;;UAGb,OAAO;AAAA;QAET,oBAAoB;AAAA,UAClB,SAAS;AAAA,UACT,QAAQ;AAAA,YACN,aAAa;AAAA,cACX,SAAS;AAAA,cACT,QAAQ;AAAA,gBACN,KAAK;AAAA,kBACH,SAAS;AAAA;;;;UAKjB,OAAO;AAAA;QAET,wBAAwB;AAAA,UACtB,SACE;AAAA,UACF,QAAQ;AAAA,YACN,aAAa;AAAA,cACX,SAAS;AAAA,cACT,QAAQ;AAAA,gBACN,KAAK;AAAA,kBACH,SAAS;AAAA;;;YAIf,WAAW;AAAA,cACT,SAAS;AAAA,cACT,QAAQ;AAAA,gBACN,aAAa;AAAA,kBACX,SAAS;AAAA;;cAGb,OAAO;AAAA;;UAGX,OAAO;AAAA;QAET,6BAA6B;AAAA,UAC3B,SAAS;AAAA,UACT,QAAQ;AAAA,YACN,aAAa;AAAA,cACX,SAAS;AAAA;;UAGb,OAAO;AAAA;QAET,yBAAyB;AAAA,UACvB,SAAS;AAAA,UACT,QAAQ;AAAA,YACN,aAAa;AAAA,cACX,SAAS;AAAA;;UAGb,OAAO;AAAA;MAEf,CAAK;AACD,MAAAA,OAAM,UAAU;AAAA,QACd;AAAA,QACA;AAAA,QACA;AAAA,UACE,UAAUA,OAAM,UAAU,MAAM,iBAAiB,EAAE,OAAO,UAAU;AAAA;QAEtEA,OAAM,UAAU,MAAM,gBAAgB;AAAA;AAExC,MAAAA,OAAM,UAAU,YAAYA,OAAM,UAAU;AAAA,IAChD,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/xml-doc-Dq9Dh3YI.js

@@ -0,0 +1,71 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.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 xmlDoc_1;
+var hasRequiredXmlDoc;
+function requireXmlDoc() {
+  if (hasRequiredXmlDoc) return xmlDoc_1;
+  hasRequiredXmlDoc = 1;
+  xmlDoc_1 = xmlDoc2;
+  xmlDoc2.displayName = "xmlDoc";
+  xmlDoc2.aliases = [];
+  function xmlDoc2(Prism) {
+    (function(Prism2) {
+      function insertDocComment(lang, docComment) {
+        if (Prism2.languages[lang]) {
+          Prism2.languages.insertBefore(lang, "comment", {
+            "doc-comment": docComment
+          });
+        }
+      }
+      var tag = Prism2.languages.markup.tag;
+      var slashDocComment = {
+        pattern: /\/\/\/.*/,
+        greedy: true,
+        alias: "comment",
+        inside: {
+          tag
+        }
+      };
+      var tickDocComment = {
+        pattern: /'''.*/,
+        greedy: true,
+        alias: "comment",
+        inside: {
+          tag
+        }
+      };
+      insertDocComment("csharp", slashDocComment);
+      insertDocComment("fsharp", slashDocComment);
+      insertDocComment("vbnet", tickDocComment);
+    })(Prism);
+  }
+  return xmlDoc_1;
+}
+var xmlDocExports = requireXmlDoc();
+const xmlDoc = /* @__PURE__ */ getDefaultExportFromCjs(xmlDocExports);
+const xmlDoc$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: xmlDoc
+}, [xmlDocExports]);
+export {
+  xmlDoc$1 as x
+};
+//# sourceMappingURL=xml-doc-Dq9Dh3YI.js.map

package/dist/xml-doc-Dq9Dh3YI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xml-doc-Dq9Dh3YI.js","sources":["../node_modules/refractor/lang/xml-doc.js"],"sourcesContent":["'use strict'\n\nmodule.exports = xmlDoc\nxmlDoc.displayName = 'xmlDoc'\nxmlDoc.aliases = []\nfunction xmlDoc(Prism) {\n  ;(function (Prism) {\n    /**\n     * If the given language is present, it will insert the given doc comment grammar token into it.\n     *\n     * @param {string} lang\n     * @param {any} docComment\n     */\n    function insertDocComment(lang, docComment) {\n      if (Prism.languages[lang]) {\n        Prism.languages.insertBefore(lang, 'comment', {\n          'doc-comment': docComment\n        })\n      }\n    }\n    var tag = Prism.languages.markup.tag\n    var slashDocComment = {\n      pattern: /\\/\\/\\/.*/,\n      greedy: true,\n      alias: 'comment',\n      inside: {\n        tag: tag\n      }\n    }\n    var tickDocComment = {\n      pattern: /'''.*/,\n      greedy: true,\n      alias: 'comment',\n      inside: {\n        tag: tag\n      }\n    }\n    insertDocComment('csharp', slashDocComment)\n    insertDocComment('fsharp', slashDocComment)\n    insertDocComment('vbnet', tickDocComment)\n  })(Prism)\n}\n"],"names":["xmlDoc","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAA;AACjB,WAASA,QAAO,OAAO;AACpB,KAAC,SAAUC,QAAO;AAOjB,eAAS,iBAAiB,MAAM,YAAY;AAC1C,YAAIA,OAAM,UAAU,IAAI,GAAG;AACzB,UAAAA,OAAM,UAAU,aAAa,MAAM,WAAW;AAAA,YAC5C,eAAe;AAAA,UACzB,CAAS;AAAA,QACT;AAAA,MACA;AACI,UAAI,MAAMA,OAAM,UAAU,OAAO;AACjC,UAAI,kBAAkB;AAAA,QACpB,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,OAAO;AAAA,QACP,QAAQ;AAAA,UACN;AAAA;;AAGJ,UAAI,iBAAiB;AAAA,QACnB,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,OAAO;AAAA,QACP,QAAQ;AAAA,UACN;AAAA;;AAGJ,uBAAiB,UAAU,eAAe;AAC1C,uBAAiB,UAAU,eAAe;AAC1C,uBAAiB,SAAS,cAAc;AAAA,IAC5C,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/xojo-DFqRRxk7.js

@@ -0,0 +1,60 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.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 xojo_1;
+var hasRequiredXojo;
+function requireXojo() {
+  if (hasRequiredXojo) return xojo_1;
+  hasRequiredXojo = 1;
+  xojo_1 = xojo2;
+  xojo2.displayName = "xojo";
+  xojo2.aliases = [];
+  function xojo2(Prism) {
+    Prism.languages.xojo = {
+      comment: {
+        pattern: /(?:'|\/\/|Rem\b).+/i,
+        greedy: true
+      },
+      string: {
+        pattern: /"(?:""|[^"])*"/,
+        greedy: true
+      },
+      number: [/(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i, /&[bchou][a-z\d]+/i],
+      directive: {
+        pattern: /#(?:Else|ElseIf|Endif|If|Pragma)\b/i,
+        alias: "property"
+      },
+      keyword: /\b(?:AddHandler|App|Array|As(?:signs)?|Auto|Boolean|Break|By(?:Ref|Val)|Byte|Call|Case|Catch|CFStringRef|CGFloat|Class|Color|Const|Continue|CString|Currency|CurrentMethodName|Declare|Delegate|Dim|Do(?:uble|wnTo)?|Each|Else(?:If)?|End|Enumeration|Event|Exception|Exit|Extends|False|Finally|For|Function|Get|GetTypeInfo|Global|GOTO|If|Implements|In|Inherits|Int(?:8|16|32|64|eger|erface)?|Lib|Loop|Me|Module|Next|Nil|Object|Optional|OSType|ParamArray|Private|Property|Protected|PString|Ptr|Raise(?:Event)?|ReDim|RemoveHandler|Return|Select(?:or)?|Self|Set|Shared|Short|Single|Soft|Static|Step|String|Sub|Super|Text|Then|To|True|Try|Ubound|UInt(?:8|16|32|64|eger)?|Until|Using|Var(?:iant)?|Wend|While|WindowPtr|WString)\b/i,
+      operator: /<[=>]?|>=?|[+\-*\/\\^=]|\b(?:AddressOf|And|Ctype|IsA?|Mod|New|Not|Or|WeakAddressOf|Xor)\b/i,
+      punctuation: /[.,;:()]/
+    };
+  }
+  return xojo_1;
+}
+var xojoExports = requireXojo();
+const xojo = /* @__PURE__ */ getDefaultExportFromCjs(xojoExports);
+const xojo$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: xojo
+}, [xojoExports]);
+export {
+  xojo$1 as x
+};
+//# sourceMappingURL=xojo-DFqRRxk7.js.map

package/dist/xojo-DFqRRxk7.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xojo-DFqRRxk7.js","sources":["../node_modules/refractor/lang/xojo.js"],"sourcesContent":["'use strict'\n\nmodule.exports = xojo\nxojo.displayName = 'xojo'\nxojo.aliases = []\nfunction xojo(Prism) {\n  Prism.languages.xojo = {\n    comment: {\n      pattern: /(?:'|\\/\\/|Rem\\b).+/i,\n      greedy: true\n    },\n    string: {\n      pattern: /\"(?:\"\"|[^\"])*\"/,\n      greedy: true\n    },\n    number: [/(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:E[+-]?\\d+)?/i, /&[bchou][a-z\\d]+/i],\n    directive: {\n      pattern: /#(?:Else|ElseIf|Endif|If|Pragma)\\b/i,\n      alias: 'property'\n    },\n    keyword:\n      /\\b(?:AddHandler|App|Array|As(?:signs)?|Auto|Boolean|Break|By(?:Ref|Val)|Byte|Call|Case|Catch|CFStringRef|CGFloat|Class|Color|Const|Continue|CString|Currency|CurrentMethodName|Declare|Delegate|Dim|Do(?:uble|wnTo)?|Each|Else(?:If)?|End|Enumeration|Event|Exception|Exit|Extends|False|Finally|For|Function|Get|GetTypeInfo|Global|GOTO|If|Implements|In|Inherits|Int(?:8|16|32|64|eger|erface)?|Lib|Loop|Me|Module|Next|Nil|Object|Optional|OSType|ParamArray|Private|Property|Protected|PString|Ptr|Raise(?:Event)?|ReDim|RemoveHandler|Return|Select(?:or)?|Self|Set|Shared|Short|Single|Soft|Static|Step|String|Sub|Super|Text|Then|To|True|Try|Ubound|UInt(?:8|16|32|64|eger)?|Until|Using|Var(?:iant)?|Wend|While|WindowPtr|WString)\\b/i,\n    operator:\n      /<[=>]?|>=?|[+\\-*\\/\\\\^=]|\\b(?:AddressOf|And|Ctype|IsA?|Mod|New|Not|Or|WeakAddressOf|Xor)\\b/i,\n    punctuation: /[.,;:()]/\n  }\n}\n"],"names":["xojo"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AACnB,UAAM,UAAU,OAAO;AAAA,MACrB,SAAS;AAAA,QACP,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,QAAQ,CAAC,8CAA8C,mBAAmB;AAAA,MAC1E,WAAW;AAAA,QACT,SAAS;AAAA,QACT,OAAO;AAAA;MAET,SACE;AAAA,MACF,UACE;AAAA,MACF,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/xquery-ZAnNGmG2.js

@@ -0,0 +1,180 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.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 xquery_1;
+var hasRequiredXquery;
+function requireXquery() {
+  if (hasRequiredXquery) return xquery_1;
+  hasRequiredXquery = 1;
+  xquery_1 = xquery2;
+  xquery2.displayName = "xquery";
+  xquery2.aliases = [];
+  function xquery2(Prism) {
+    (function(Prism2) {
+      Prism2.languages.xquery = Prism2.languages.extend("markup", {
+        "xquery-comment": {
+          pattern: /\(:[\s\S]*?:\)/,
+          greedy: true,
+          alias: "comment"
+        },
+        string: {
+          pattern: /(["'])(?:\1\1|(?!\1)[\s\S])*\1/,
+          greedy: true
+        },
+        extension: {
+          pattern: /\(#.+?#\)/,
+          alias: "symbol"
+        },
+        variable: /\$[-\w:]+/,
+        axis: {
+          pattern: /(^|[^-])(?:ancestor(?:-or-self)?|attribute|child|descendant(?:-or-self)?|following(?:-sibling)?|parent|preceding(?:-sibling)?|self)(?=::)/,
+          lookbehind: true,
+          alias: "operator"
+        },
+        "keyword-operator": {
+          pattern: /(^|[^:-])\b(?:and|castable as|div|eq|except|ge|gt|idiv|instance of|intersect|is|le|lt|mod|ne|or|union)\b(?=$|[^:-])/,
+          lookbehind: true,
+          alias: "operator"
+        },
+        keyword: {
+          pattern: /(^|[^:-])\b(?:as|ascending|at|base-uri|boundary-space|case|cast as|collation|construction|copy-namespaces|declare|default|descending|else|empty (?:greatest|least)|encoding|every|external|for|function|if|import|in|inherit|lax|let|map|module|namespace|no-inherit|no-preserve|option|order(?: by|ed|ing)?|preserve|return|satisfies|schema|some|stable|strict|strip|then|to|treat as|typeswitch|unordered|validate|variable|version|where|xquery)\b(?=$|[^:-])/,
+          lookbehind: true
+        },
+        function: /[\w-]+(?::[\w-]+)*(?=\s*\()/,
+        "xquery-element": {
+          pattern: /(element\s+)[\w-]+(?::[\w-]+)*/,
+          lookbehind: true,
+          alias: "tag"
+        },
+        "xquery-attribute": {
+          pattern: /(attribute\s+)[\w-]+(?::[\w-]+)*/,
+          lookbehind: true,
+          alias: "attr-name"
+        },
+        builtin: {
+          pattern: /(^|[^:-])\b(?:attribute|comment|document|element|processing-instruction|text|xs:(?:ENTITIES|ENTITY|ID|IDREFS?|NCName|NMTOKENS?|NOTATION|Name|QName|anyAtomicType|anyType|anyURI|base64Binary|boolean|byte|date|dateTime|dayTimeDuration|decimal|double|duration|float|gDay|gMonth|gMonthDay|gYear|gYearMonth|hexBinary|int|integer|language|long|negativeInteger|nonNegativeInteger|nonPositiveInteger|normalizedString|positiveInteger|short|string|time|token|unsigned(?:Byte|Int|Long|Short)|untyped(?:Atomic)?|yearMonthDuration))\b(?=$|[^:-])/,
+          lookbehind: true
+        },
+        number: /\b\d+(?:\.\d+)?(?:E[+-]?\d+)?/,
+        operator: [
+          /[+*=?|@]|\.\.?|:=|!=|<[=<]?|>[=>]?/,
+          {
+            pattern: /(\s)-(?=\s)/,
+            lookbehind: true
+          }
+        ],
+        punctuation: /[[\](){},;:/]/
+      });
+      Prism2.languages.xquery.tag.pattern = /<\/?(?!\d)[^\s>\/=$<%]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|\{(?!\{)(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])+\}|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/;
+      Prism2.languages.xquery["tag"].inside["attr-value"].pattern = /=(?:("|')(?:\\[\s\S]|\{(?!\{)(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])+\}|(?!\1)[^\\])*\1|[^\s'">=]+)/;
+      Prism2.languages.xquery["tag"].inside["attr-value"].inside["punctuation"] = /^="|"$/;
+      Prism2.languages.xquery["tag"].inside["attr-value"].inside["expression"] = {
+        // Allow for two levels of nesting
+        pattern: /\{(?!\{)(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])+\}/,
+        inside: Prism2.languages.xquery,
+        alias: "language-xquery"
+      };
+      var stringifyToken = function(token) {
+        if (typeof token === "string") {
+          return token;
+        }
+        if (typeof token.content === "string") {
+          return token.content;
+        }
+        return token.content.map(stringifyToken).join("");
+      };
+      var walkTokens = function(tokens) {
+        var openedTags = [];
+        for (var i = 0; i < tokens.length; i++) {
+          var token = tokens[i];
+          var notTagNorBrace = false;
+          if (typeof token !== "string") {
+            if (token.type === "tag" && token.content[0] && token.content[0].type === "tag") {
+              if (token.content[0].content[0].content === "</") {
+                if (openedTags.length > 0 && openedTags[openedTags.length - 1].tagName === stringifyToken(token.content[0].content[1])) {
+                  openedTags.pop();
+                }
+              } else {
+                if (token.content[token.content.length - 1].content === "/>") ;
+                else {
+                  openedTags.push({
+                    tagName: stringifyToken(token.content[0].content[1]),
+                    openedBraces: 0
+                  });
+                }
+              }
+            } else if (openedTags.length > 0 && token.type === "punctuation" && token.content === "{" && // Ignore `{{`
+            (!tokens[i + 1] || tokens[i + 1].type !== "punctuation" || tokens[i + 1].content !== "{") && (!tokens[i - 1] || tokens[i - 1].type !== "plain-text" || tokens[i - 1].content !== "{")) {
+              openedTags[openedTags.length - 1].openedBraces++;
+            } else if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces > 0 && token.type === "punctuation" && token.content === "}") {
+              openedTags[openedTags.length - 1].openedBraces--;
+            } else if (token.type !== "comment") {
+              notTagNorBrace = true;
+            }
+          }
+          if (notTagNorBrace || typeof token === "string") {
+            if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces === 0) {
+              var plainText = stringifyToken(token);
+              if (i < tokens.length - 1 && (typeof tokens[i + 1] === "string" || tokens[i + 1].type === "plain-text")) {
+                plainText += stringifyToken(tokens[i + 1]);
+                tokens.splice(i + 1, 1);
+              }
+              if (i > 0 && (typeof tokens[i - 1] === "string" || tokens[i - 1].type === "plain-text")) {
+                plainText = stringifyToken(tokens[i - 1]) + plainText;
+                tokens.splice(i - 1, 1);
+                i--;
+              }
+              if (/^\s+$/.test(plainText)) {
+                tokens[i] = plainText;
+              } else {
+                tokens[i] = new Prism2.Token(
+                  "plain-text",
+                  plainText,
+                  null,
+                  plainText
+                );
+              }
+            }
+          }
+          if (token.content && typeof token.content !== "string") {
+            walkTokens(token.content);
+          }
+        }
+      };
+      Prism2.hooks.add("after-tokenize", function(env) {
+        if (env.language !== "xquery") {
+          return;
+        }
+        walkTokens(env.tokens);
+      });
+    })(Prism);
+  }
+  return xquery_1;
+}
+var xqueryExports = requireXquery();
+const xquery = /* @__PURE__ */ getDefaultExportFromCjs(xqueryExports);
+const xquery$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: xquery
+}, [xqueryExports]);
+export {
+  xquery$1 as x
+};
+//# sourceMappingURL=xquery-ZAnNGmG2.js.map

package/dist/xquery-ZAnNGmG2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xquery-ZAnNGmG2.js","sources":["../node_modules/refractor/lang/xquery.js"],"sourcesContent":["'use strict'\n\nmodule.exports = xquery\nxquery.displayName = 'xquery'\nxquery.aliases = []\nfunction xquery(Prism) {\n  ;(function (Prism) {\n    Prism.languages.xquery = Prism.languages.extend('markup', {\n      'xquery-comment': {\n        pattern: /\\(:[\\s\\S]*?:\\)/,\n        greedy: true,\n        alias: 'comment'\n      },\n      string: {\n        pattern: /([\"'])(?:\\1\\1|(?!\\1)[\\s\\S])*\\1/,\n        greedy: true\n      },\n      extension: {\n        pattern: /\\(#.+?#\\)/,\n        alias: 'symbol'\n      },\n      variable: /\\$[-\\w:]+/,\n      axis: {\n        pattern:\n          /(^|[^-])(?:ancestor(?:-or-self)?|attribute|child|descendant(?:-or-self)?|following(?:-sibling)?|parent|preceding(?:-sibling)?|self)(?=::)/,\n        lookbehind: true,\n        alias: 'operator'\n      },\n      'keyword-operator': {\n        pattern:\n          /(^|[^:-])\\b(?:and|castable as|div|eq|except|ge|gt|idiv|instance of|intersect|is|le|lt|mod|ne|or|union)\\b(?=$|[^:-])/,\n        lookbehind: true,\n        alias: 'operator'\n      },\n      keyword: {\n        pattern:\n          /(^|[^:-])\\b(?:as|ascending|at|base-uri|boundary-space|case|cast as|collation|construction|copy-namespaces|declare|default|descending|else|empty (?:greatest|least)|encoding|every|external|for|function|if|import|in|inherit|lax|let|map|module|namespace|no-inherit|no-preserve|option|order(?: by|ed|ing)?|preserve|return|satisfies|schema|some|stable|strict|strip|then|to|treat as|typeswitch|unordered|validate|variable|version|where|xquery)\\b(?=$|[^:-])/,\n        lookbehind: true\n      },\n      function: /[\\w-]+(?::[\\w-]+)*(?=\\s*\\()/,\n      'xquery-element': {\n        pattern: /(element\\s+)[\\w-]+(?::[\\w-]+)*/,\n        lookbehind: true,\n        alias: 'tag'\n      },\n      'xquery-attribute': {\n        pattern: /(attribute\\s+)[\\w-]+(?::[\\w-]+)*/,\n        lookbehind: true,\n        alias: 'attr-name'\n      },\n      builtin: {\n        pattern:\n          /(^|[^:-])\\b(?:attribute|comment|document|element|processing-instruction|text|xs:(?:ENTITIES|ENTITY|ID|IDREFS?|NCName|NMTOKENS?|NOTATION|Name|QName|anyAtomicType|anyType|anyURI|base64Binary|boolean|byte|date|dateTime|dayTimeDuration|decimal|double|duration|float|gDay|gMonth|gMonthDay|gYear|gYearMonth|hexBinary|int|integer|language|long|negativeInteger|nonNegativeInteger|nonPositiveInteger|normalizedString|positiveInteger|short|string|time|token|unsigned(?:Byte|Int|Long|Short)|untyped(?:Atomic)?|yearMonthDuration))\\b(?=$|[^:-])/,\n        lookbehind: true\n      },\n      number: /\\b\\d+(?:\\.\\d+)?(?:E[+-]?\\d+)?/,\n      operator: [\n        /[+*=?|@]|\\.\\.?|:=|!=|<[=<]?|>[=>]?/,\n        {\n          pattern: /(\\s)-(?=\\s)/,\n          lookbehind: true\n        }\n      ],\n      punctuation: /[[\\](){},;:/]/\n    })\n    Prism.languages.xquery.tag.pattern =\n      /<\\/?(?!\\d)[^\\s>\\/=$<%]+(?:\\s+[^\\s>\\/=]+(?:=(?:(\"|')(?:\\\\[\\s\\S]|\\{(?!\\{)(?:\\{(?:\\{[^{}]*\\}|[^{}])*\\}|[^{}])+\\}|(?!\\1)[^\\\\])*\\1|[^\\s'\">=]+))?)*\\s*\\/?>/\n    Prism.languages.xquery['tag'].inside['attr-value'].pattern =\n      /=(?:(\"|')(?:\\\\[\\s\\S]|\\{(?!\\{)(?:\\{(?:\\{[^{}]*\\}|[^{}])*\\}|[^{}])+\\}|(?!\\1)[^\\\\])*\\1|[^\\s'\">=]+)/\n    Prism.languages.xquery['tag'].inside['attr-value'].inside['punctuation'] =\n      /^=\"|\"$/\n    Prism.languages.xquery['tag'].inside['attr-value'].inside['expression'] = {\n      // Allow for two levels of nesting\n      pattern: /\\{(?!\\{)(?:\\{(?:\\{[^{}]*\\}|[^{}])*\\}|[^{}])+\\}/,\n      inside: Prism.languages.xquery,\n      alias: 'language-xquery'\n    } // The following will handle plain text inside tags\n    var stringifyToken = function (token) {\n      if (typeof token === 'string') {\n        return token\n      }\n      if (typeof token.content === 'string') {\n        return token.content\n      }\n      return token.content.map(stringifyToken).join('')\n    }\n    var walkTokens = function (tokens) {\n      var openedTags = []\n      for (var i = 0; i < tokens.length; i++) {\n        var token = tokens[i]\n        var notTagNorBrace = false\n        if (typeof token !== 'string') {\n          if (\n            token.type === 'tag' &&\n            token.content[0] &&\n            token.content[0].type === 'tag'\n          ) {\n            // We found a tag, now find its kind\n            if (token.content[0].content[0].content === '</') {\n              // Closing tag\n              if (\n                openedTags.length > 0 &&\n                openedTags[openedTags.length - 1].tagName ===\n                  stringifyToken(token.content[0].content[1])\n              ) {\n                // Pop matching opening tag\n                openedTags.pop()\n              }\n            } else {\n              if (token.content[token.content.length - 1].content === '/>') {\n                // Autoclosed tag, ignore\n              } else {\n                // Opening tag\n                openedTags.push({\n                  tagName: stringifyToken(token.content[0].content[1]),\n                  openedBraces: 0\n                })\n              }\n            }\n          } else if (\n            openedTags.length > 0 &&\n            token.type === 'punctuation' &&\n            token.content === '{' && // Ignore `{{`\n            (!tokens[i + 1] ||\n              tokens[i + 1].type !== 'punctuation' ||\n              tokens[i + 1].content !== '{') &&\n            (!tokens[i - 1] ||\n              tokens[i - 1].type !== 'plain-text' ||\n              tokens[i - 1].content !== '{')\n          ) {\n            // Here we might have entered an XQuery expression inside a tag\n            openedTags[openedTags.length - 1].openedBraces++\n          } else if (\n            openedTags.length > 0 &&\n            openedTags[openedTags.length - 1].openedBraces > 0 &&\n            token.type === 'punctuation' &&\n            token.content === '}'\n          ) {\n            // Here we might have left an XQuery expression inside a tag\n            openedTags[openedTags.length - 1].openedBraces--\n          } else if (token.type !== 'comment') {\n            notTagNorBrace = true\n          }\n        }\n        if (notTagNorBrace || typeof token === 'string') {\n          if (\n            openedTags.length > 0 &&\n            openedTags[openedTags.length - 1].openedBraces === 0\n          ) {\n            // Here we are inside a tag, and not inside an XQuery expression.\n            // That's plain text: drop any tokens matched.\n            var plainText = stringifyToken(token) // And merge text with adjacent text\n            if (\n              i < tokens.length - 1 &&\n              (typeof tokens[i + 1] === 'string' ||\n                tokens[i + 1].type === 'plain-text')\n            ) {\n              plainText += stringifyToken(tokens[i + 1])\n              tokens.splice(i + 1, 1)\n            }\n            if (\n              i > 0 &&\n              (typeof tokens[i - 1] === 'string' ||\n                tokens[i - 1].type === 'plain-text')\n            ) {\n              plainText = stringifyToken(tokens[i - 1]) + plainText\n              tokens.splice(i - 1, 1)\n              i--\n            }\n            if (/^\\s+$/.test(plainText)) {\n              tokens[i] = plainText\n            } else {\n              tokens[i] = new Prism.Token(\n                'plain-text',\n                plainText,\n                null,\n                plainText\n              )\n            }\n          }\n        }\n        if (token.content && typeof token.content !== 'string') {\n          walkTokens(token.content)\n        }\n      }\n    }\n    Prism.hooks.add('after-tokenize', function (env) {\n      if (env.language !== 'xquery') {\n        return\n      }\n      walkTokens(env.tokens)\n    })\n  })(Prism)\n}\n"],"names":["xquery","Prism"],"mappings":"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","x_google_ignoreList":[0]}