@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/moonscript-Czhm161R.js

@@ -0,0 +1,98 @@
+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 moonscript_1;
+var hasRequiredMoonscript;
+function requireMoonscript() {
+  if (hasRequiredMoonscript) return moonscript_1;
+  hasRequiredMoonscript = 1;
+  moonscript_1 = moonscript2;
+  moonscript2.displayName = "moonscript";
+  moonscript2.aliases = ["moon"];
+  function moonscript2(Prism) {
+    Prism.languages.moonscript = {
+      comment: /--.*/,
+      string: [
+        {
+          pattern: /'[^']*'|\[(=*)\[[\s\S]*?\]\1\]/,
+          greedy: true
+        },
+        {
+          pattern: /"[^"]*"/,
+          greedy: true,
+          inside: {
+            interpolation: {
+              pattern: /#\{[^{}]*\}/,
+              inside: {
+                moonscript: {
+                  pattern: /(^#\{)[\s\S]+(?=\})/,
+                  lookbehind: true,
+                  inside: null
+                  // see beow
+                },
+                "interpolation-punctuation": {
+                  pattern: /#\{|\}/,
+                  alias: "punctuation"
+                }
+              }
+            }
+          }
+        }
+      ],
+      "class-name": [
+        {
+          pattern: /(\b(?:class|extends)[ \t]+)\w+/,
+          lookbehind: true
+        },
+        // class-like names start with a capital letter
+        /\b[A-Z]\w*/
+      ],
+      keyword: /\b(?:class|continue|do|else|elseif|export|extends|for|from|if|import|in|local|nil|return|self|super|switch|then|unless|using|when|while|with)\b/,
+      variable: /@@?\w*/,
+      property: {
+        pattern: /\b(?!\d)\w+(?=:)|(:)(?!\d)\w+/,
+        lookbehind: true
+      },
+      function: {
+        pattern: /\b(?:_G|_VERSION|assert|collectgarbage|coroutine\.(?:create|resume|running|status|wrap|yield)|debug\.(?:debug|getfenv|gethook|getinfo|getlocal|getmetatable|getregistry|getupvalue|setfenv|sethook|setlocal|setmetatable|setupvalue|traceback)|dofile|error|getfenv|getmetatable|io\.(?:close|flush|input|lines|open|output|popen|read|stderr|stdin|stdout|tmpfile|type|write)|ipairs|load|loadfile|loadstring|math\.(?:abs|acos|asin|atan|atan2|ceil|cos|cosh|deg|exp|floor|fmod|frexp|ldexp|log|log10|max|min|modf|pi|pow|rad|random|randomseed|sin|sinh|sqrt|tan|tanh)|module|next|os\.(?:clock|date|difftime|execute|exit|getenv|remove|rename|setlocale|time|tmpname)|package\.(?:cpath|loaded|loadlib|path|preload|seeall)|pairs|pcall|print|rawequal|rawget|rawset|require|select|setfenv|setmetatable|string\.(?:byte|char|dump|find|format|gmatch|gsub|len|lower|match|rep|reverse|sub|upper)|table\.(?:concat|insert|maxn|remove|sort)|tonumber|tostring|type|unpack|xpcall)\b/,
+        inside: {
+          punctuation: /\./
+        }
+      },
+      boolean: /\b(?:false|true)\b/,
+      number: /(?:\B\.\d+|\b\d+\.\d+|\b\d+(?=[eE]))(?:[eE][-+]?\d+)?\b|\b(?:0x[a-fA-F\d]+|\d+)(?:U?LL)?\b/,
+      operator: /\.{3}|[-=]>|~=|(?:[-+*/%<>!=]|\.\.)=?|[:#^]|\b(?:and|or)\b=?|\b(?:not)\b/,
+      punctuation: /[.,()[\]{}\\]/
+    };
+    Prism.languages.moonscript.string[1].inside.interpolation.inside.moonscript.inside = Prism.languages.moonscript;
+    Prism.languages.moon = Prism.languages.moonscript;
+  }
+  return moonscript_1;
+}
+var moonscriptExports = requireMoonscript();
+const moonscript = /* @__PURE__ */ getDefaultExportFromCjs(moonscriptExports);
+const moonscript$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: moonscript
+}, [moonscriptExports]);
+export {
+  moonscript$1 as m
+};
+//# sourceMappingURL=moonscript-Czhm161R.js.map

package/dist/moonscript-Czhm161R.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"moonscript-Czhm161R.js","sources":["../node_modules/refractor/lang/moonscript.js"],"sourcesContent":["'use strict'\n\nmodule.exports = moonscript\nmoonscript.displayName = 'moonscript'\nmoonscript.aliases = ['moon']\nfunction moonscript(Prism) {\n  Prism.languages.moonscript = {\n    comment: /--.*/,\n    string: [\n      {\n        pattern: /'[^']*'|\\[(=*)\\[[\\s\\S]*?\\]\\1\\]/,\n        greedy: true\n      },\n      {\n        pattern: /\"[^\"]*\"/,\n        greedy: true,\n        inside: {\n          interpolation: {\n            pattern: /#\\{[^{}]*\\}/,\n            inside: {\n              moonscript: {\n                pattern: /(^#\\{)[\\s\\S]+(?=\\})/,\n                lookbehind: true,\n                inside: null // see beow\n              },\n              'interpolation-punctuation': {\n                pattern: /#\\{|\\}/,\n                alias: 'punctuation'\n              }\n            }\n          }\n        }\n      }\n    ],\n    'class-name': [\n      {\n        pattern: /(\\b(?:class|extends)[ \\t]+)\\w+/,\n        lookbehind: true\n      }, // class-like names start with a capital letter\n      /\\b[A-Z]\\w*/\n    ],\n    keyword:\n      /\\b(?:class|continue|do|else|elseif|export|extends|for|from|if|import|in|local|nil|return|self|super|switch|then|unless|using|when|while|with)\\b/,\n    variable: /@@?\\w*/,\n    property: {\n      pattern: /\\b(?!\\d)\\w+(?=:)|(:)(?!\\d)\\w+/,\n      lookbehind: true\n    },\n    function: {\n      pattern:\n        /\\b(?:_G|_VERSION|assert|collectgarbage|coroutine\\.(?:create|resume|running|status|wrap|yield)|debug\\.(?:debug|getfenv|gethook|getinfo|getlocal|getmetatable|getregistry|getupvalue|setfenv|sethook|setlocal|setmetatable|setupvalue|traceback)|dofile|error|getfenv|getmetatable|io\\.(?:close|flush|input|lines|open|output|popen|read|stderr|stdin|stdout|tmpfile|type|write)|ipairs|load|loadfile|loadstring|math\\.(?:abs|acos|asin|atan|atan2|ceil|cos|cosh|deg|exp|floor|fmod|frexp|ldexp|log|log10|max|min|modf|pi|pow|rad|random|randomseed|sin|sinh|sqrt|tan|tanh)|module|next|os\\.(?:clock|date|difftime|execute|exit|getenv|remove|rename|setlocale|time|tmpname)|package\\.(?:cpath|loaded|loadlib|path|preload|seeall)|pairs|pcall|print|rawequal|rawget|rawset|require|select|setfenv|setmetatable|string\\.(?:byte|char|dump|find|format|gmatch|gsub|len|lower|match|rep|reverse|sub|upper)|table\\.(?:concat|insert|maxn|remove|sort)|tonumber|tostring|type|unpack|xpcall)\\b/,\n      inside: {\n        punctuation: /\\./\n      }\n    },\n    boolean: /\\b(?:false|true)\\b/,\n    number:\n      /(?:\\B\\.\\d+|\\b\\d+\\.\\d+|\\b\\d+(?=[eE]))(?:[eE][-+]?\\d+)?\\b|\\b(?:0x[a-fA-F\\d]+|\\d+)(?:U?LL)?\\b/,\n    operator:\n      /\\.{3}|[-=]>|~=|(?:[-+*/%<>!=]|\\.\\.)=?|[:#^]|\\b(?:and|or)\\b=?|\\b(?:not)\\b/,\n    punctuation: /[.,()[\\]{}\\\\]/\n  }\n  Prism.languages.moonscript.string[1].inside.interpolation.inside.moonscript.inside =\n    Prism.languages.moonscript\n  Prism.languages.moon = Prism.languages.moonscript\n}\n"],"names":["moonscript"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,iBAAiBA;AACjB,EAAAA,YAAW,cAAc;AACzB,EAAAA,YAAW,UAAU,CAAC,MAAM;AAC5B,WAASA,YAAW,OAAO;AACzB,UAAM,UAAU,aAAa;AAAA,MAC3B,SAAS;AAAA,MACT,QAAQ;AAAA,QACN;AAAA,UACE,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV;AAAA,UACE,SAAS;AAAA,UACT,QAAQ;AAAA,UACR,QAAQ;AAAA,YACN,eAAe;AAAA,cACb,SAAS;AAAA,cACT,QAAQ;AAAA,gBACN,YAAY;AAAA,kBACV,SAAS;AAAA,kBACT,YAAY;AAAA,kBACZ,QAAQ;AAAA;AAAA;gBAEV,6BAA6B;AAAA,kBAC3B,SAAS;AAAA,kBACT,OAAO;AAAA;;;;;;MAOnB,cAAc;AAAA,QACZ;AAAA,UACE,SAAS;AAAA,UACT,YAAY;AAAA;;QAEd;AAAA;MAEF,SACE;AAAA,MACF,UAAU;AAAA,MACV,UAAU;AAAA,QACR,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,UAAU;AAAA,QACR,SACE;AAAA,QACF,QAAQ;AAAA,UACN,aAAa;AAAA;;MAGjB,SAAS;AAAA,MACT,QACE;AAAA,MACF,UACE;AAAA,MACF,aAAa;AAAA;AAEf,UAAM,UAAU,WAAW,OAAO,CAAC,EAAE,OAAO,cAAc,OAAO,WAAW,SAC1E,MAAM,UAAU;AAClB,UAAM,UAAU,OAAO,MAAM,UAAU;AAAA,EACzC;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/n1ql-DVNXi6hD.js

@@ -0,0 +1,64 @@
+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 n1ql_1;
+var hasRequiredN1ql;
+function requireN1ql() {
+  if (hasRequiredN1ql) return n1ql_1;
+  hasRequiredN1ql = 1;
+  n1ql_1 = n1ql2;
+  n1ql2.displayName = "n1ql";
+  n1ql2.aliases = [];
+  function n1ql2(Prism) {
+    Prism.languages.n1ql = {
+      comment: {
+        pattern: /\/\*[\s\S]*?(?:$|\*\/)|--.*/,
+        greedy: true
+      },
+      string: {
+        pattern: /(["'])(?:\\[\s\S]|(?!\1)[^\\]|\1\1)*\1/,
+        greedy: true
+      },
+      identifier: {
+        pattern: /`(?:\\[\s\S]|[^\\`]|``)*`/,
+        greedy: true
+      },
+      parameter: /\$[\w.]+/,
+      // https://docs.couchbase.com/server/current/n1ql/n1ql-language-reference/reservedwords.html#n1ql-reserved-words
+      keyword: /\b(?:ADVISE|ALL|ALTER|ANALYZE|AS|ASC|AT|BEGIN|BINARY|BOOLEAN|BREAK|BUCKET|BUILD|BY|CALL|CAST|CLUSTER|COLLATE|COLLECTION|COMMIT|COMMITTED|CONNECT|CONTINUE|CORRELATE|CORRELATED|COVER|CREATE|CURRENT|DATABASE|DATASET|DATASTORE|DECLARE|DECREMENT|DELETE|DERIVED|DESC|DESCRIBE|DISTINCT|DO|DROP|EACH|ELEMENT|EXCEPT|EXCLUDE|EXECUTE|EXPLAIN|FETCH|FILTER|FLATTEN|FLUSH|FOLLOWING|FOR|FORCE|FROM|FTS|FUNCTION|GOLANG|GRANT|GROUP|GROUPS|GSI|HASH|HAVING|IF|IGNORE|ILIKE|INCLUDE|INCREMENT|INDEX|INFER|INLINE|INNER|INSERT|INTERSECT|INTO|IS|ISOLATION|JAVASCRIPT|JOIN|KEY|KEYS|KEYSPACE|KNOWN|LANGUAGE|LAST|LEFT|LET|LETTING|LEVEL|LIMIT|LSM|MAP|MAPPING|MATCHED|MATERIALIZED|MERGE|MINUS|MISSING|NAMESPACE|NEST|NL|NO|NTH_VALUE|NULL|NULLS|NUMBER|OBJECT|OFFSET|ON|OPTION|OPTIONS|ORDER|OTHERS|OUTER|OVER|PARSE|PARTITION|PASSWORD|PATH|POOL|PRECEDING|PREPARE|PRIMARY|PRIVATE|PRIVILEGE|PROBE|PROCEDURE|PUBLIC|RANGE|RAW|REALM|REDUCE|RENAME|RESPECT|RETURN|RETURNING|REVOKE|RIGHT|ROLE|ROLLBACK|ROW|ROWS|SATISFIES|SAVEPOINT|SCHEMA|SCOPE|SELECT|SELF|SEMI|SET|SHOW|SOME|START|STATISTICS|STRING|SYSTEM|TIES|TO|TRAN|TRANSACTION|TRIGGER|TRUNCATE|UNBOUNDED|UNDER|UNION|UNIQUE|UNKNOWN|UNNEST|UNSET|UPDATE|UPSERT|USE|USER|USING|VALIDATE|VALUE|VALUES|VIA|VIEW|WHERE|WHILE|WINDOW|WITH|WORK|XOR)\b/i,
+      function: /\b[a-z_]\w*(?=\s*\()/i,
+      boolean: /\b(?:FALSE|TRUE)\b/i,
+      number: /(?:\b\d+\.|\B\.)\d+e[+\-]?\d+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i,
+      operator: /[-+*\/%]|!=|==?|\|\||<[>=]?|>=?|\b(?:AND|ANY|ARRAY|BETWEEN|CASE|ELSE|END|EVERY|EXISTS|FIRST|IN|LIKE|NOT|OR|THEN|VALUED|WHEN|WITHIN)\b/i,
+      punctuation: /[;[\](),.{}:]/
+    };
+  }
+  return n1ql_1;
+}
+var n1qlExports = requireN1ql();
+const n1ql = /* @__PURE__ */ getDefaultExportFromCjs(n1qlExports);
+const n1ql$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: n1ql
+}, [n1qlExports]);
+export {
+  n1ql$1 as n
+};
+//# sourceMappingURL=n1ql-DVNXi6hD.js.map

package/dist/n1ql-DVNXi6hD.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"n1ql-DVNXi6hD.js","sources":["../node_modules/refractor/lang/n1ql.js"],"sourcesContent":["'use strict'\n\nmodule.exports = n1ql\nn1ql.displayName = 'n1ql'\nn1ql.aliases = []\nfunction n1ql(Prism) {\n  // https://docs.couchbase.com/server/current/n1ql/n1ql-language-reference/index.html\n  Prism.languages.n1ql = {\n    comment: {\n      pattern: /\\/\\*[\\s\\S]*?(?:$|\\*\\/)|--.*/,\n      greedy: true\n    },\n    string: {\n      pattern: /([\"'])(?:\\\\[\\s\\S]|(?!\\1)[^\\\\]|\\1\\1)*\\1/,\n      greedy: true\n    },\n    identifier: {\n      pattern: /`(?:\\\\[\\s\\S]|[^\\\\`]|``)*`/,\n      greedy: true\n    },\n    parameter: /\\$[\\w.]+/,\n    // https://docs.couchbase.com/server/current/n1ql/n1ql-language-reference/reservedwords.html#n1ql-reserved-words\n    keyword:\n      /\\b(?:ADVISE|ALL|ALTER|ANALYZE|AS|ASC|AT|BEGIN|BINARY|BOOLEAN|BREAK|BUCKET|BUILD|BY|CALL|CAST|CLUSTER|COLLATE|COLLECTION|COMMIT|COMMITTED|CONNECT|CONTINUE|CORRELATE|CORRELATED|COVER|CREATE|CURRENT|DATABASE|DATASET|DATASTORE|DECLARE|DECREMENT|DELETE|DERIVED|DESC|DESCRIBE|DISTINCT|DO|DROP|EACH|ELEMENT|EXCEPT|EXCLUDE|EXECUTE|EXPLAIN|FETCH|FILTER|FLATTEN|FLUSH|FOLLOWING|FOR|FORCE|FROM|FTS|FUNCTION|GOLANG|GRANT|GROUP|GROUPS|GSI|HASH|HAVING|IF|IGNORE|ILIKE|INCLUDE|INCREMENT|INDEX|INFER|INLINE|INNER|INSERT|INTERSECT|INTO|IS|ISOLATION|JAVASCRIPT|JOIN|KEY|KEYS|KEYSPACE|KNOWN|LANGUAGE|LAST|LEFT|LET|LETTING|LEVEL|LIMIT|LSM|MAP|MAPPING|MATCHED|MATERIALIZED|MERGE|MINUS|MISSING|NAMESPACE|NEST|NL|NO|NTH_VALUE|NULL|NULLS|NUMBER|OBJECT|OFFSET|ON|OPTION|OPTIONS|ORDER|OTHERS|OUTER|OVER|PARSE|PARTITION|PASSWORD|PATH|POOL|PRECEDING|PREPARE|PRIMARY|PRIVATE|PRIVILEGE|PROBE|PROCEDURE|PUBLIC|RANGE|RAW|REALM|REDUCE|RENAME|RESPECT|RETURN|RETURNING|REVOKE|RIGHT|ROLE|ROLLBACK|ROW|ROWS|SATISFIES|SAVEPOINT|SCHEMA|SCOPE|SELECT|SELF|SEMI|SET|SHOW|SOME|START|STATISTICS|STRING|SYSTEM|TIES|TO|TRAN|TRANSACTION|TRIGGER|TRUNCATE|UNBOUNDED|UNDER|UNION|UNIQUE|UNKNOWN|UNNEST|UNSET|UPDATE|UPSERT|USE|USER|USING|VALIDATE|VALUE|VALUES|VIA|VIEW|WHERE|WHILE|WINDOW|WITH|WORK|XOR)\\b/i,\n    function: /\\b[a-z_]\\w*(?=\\s*\\()/i,\n    boolean: /\\b(?:FALSE|TRUE)\\b/i,\n    number: /(?:\\b\\d+\\.|\\B\\.)\\d+e[+\\-]?\\d+\\b|\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+\\b/i,\n    operator:\n      /[-+*\\/%]|!=|==?|\\|\\||<[>=]?|>=?|\\b(?:AND|ANY|ARRAY|BETWEEN|CASE|ELSE|END|EVERY|EXISTS|FIRST|IN|LIKE|NOT|OR|THEN|VALUED|WHEN|WITHIN)\\b/i,\n    punctuation: /[;[\\](),.{}:]/\n  }\n}\n"],"names":["n1ql"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AAEnB,UAAM,UAAU,OAAO;AAAA,MACrB,SAAS;AAAA,QACP,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,YAAY;AAAA,QACV,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,WAAW;AAAA;AAAA,MAEX,SACE;AAAA,MACF,UAAU;AAAA,MACV,SAAS;AAAA,MACT,QAAQ;AAAA,MACR,UACE;AAAA,MACF,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/n4js-Cfstl6Ac.js

@@ -0,0 +1,54 @@
+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 n4js_1;
+var hasRequiredN4js;
+function requireN4js() {
+  if (hasRequiredN4js) return n4js_1;
+  hasRequiredN4js = 1;
+  n4js_1 = n4js2;
+  n4js2.displayName = "n4js";
+  n4js2.aliases = ["n4jsd"];
+  function n4js2(Prism) {
+    Prism.languages.n4js = Prism.languages.extend("javascript", {
+      // Keywords from N4JS language spec: https://numberfour.github.io/n4js/spec/N4JSSpec.html
+      keyword: /\b(?:Array|any|boolean|break|case|catch|class|const|constructor|continue|debugger|declare|default|delete|do|else|enum|export|extends|false|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|module|new|null|number|package|private|protected|public|return|set|static|string|super|switch|this|throw|true|try|typeof|var|void|while|with|yield)\b/
+    });
+    Prism.languages.insertBefore("n4js", "constant", {
+      // Annotations in N4JS spec: https://numberfour.github.io/n4js/spec/N4JSSpec.html#_annotations
+      annotation: {
+        pattern: /@+\w+/,
+        alias: "operator"
+      }
+    });
+    Prism.languages.n4jsd = Prism.languages.n4js;
+  }
+  return n4js_1;
+}
+var n4jsExports = requireN4js();
+const n4js = /* @__PURE__ */ getDefaultExportFromCjs(n4jsExports);
+const n4js$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: n4js
+}, [n4jsExports]);
+export {
+  n4js$1 as n
+};
+//# sourceMappingURL=n4js-Cfstl6Ac.js.map

package/dist/n4js-Cfstl6Ac.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"n4js-Cfstl6Ac.js","sources":["../node_modules/refractor/lang/n4js.js"],"sourcesContent":["'use strict'\n\nmodule.exports = n4js\nn4js.displayName = 'n4js'\nn4js.aliases = ['n4jsd']\nfunction n4js(Prism) {\n  Prism.languages.n4js = Prism.languages.extend('javascript', {\n    // Keywords from N4JS language spec: https://numberfour.github.io/n4js/spec/N4JSSpec.html\n    keyword:\n      /\\b(?:Array|any|boolean|break|case|catch|class|const|constructor|continue|debugger|declare|default|delete|do|else|enum|export|extends|false|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|module|new|null|number|package|private|protected|public|return|set|static|string|super|switch|this|throw|true|try|typeof|var|void|while|with|yield)\\b/\n  })\n  Prism.languages.insertBefore('n4js', 'constant', {\n    // Annotations in N4JS spec: https://numberfour.github.io/n4js/spec/N4JSSpec.html#_annotations\n    annotation: {\n      pattern: /@+\\w+/,\n      alias: 'operator'\n    }\n  })\n  Prism.languages.n4jsd = Prism.languages.n4js\n}\n"],"names":["n4js"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAC,OAAO;AACvB,WAASA,MAAK,OAAO;AACnB,UAAM,UAAU,OAAO,MAAM,UAAU,OAAO,cAAc;AAAA;AAAA,MAE1D,SACE;AAAA,IACN,CAAG;AACD,UAAM,UAAU,aAAa,QAAQ,YAAY;AAAA;AAAA,MAE/C,YAAY;AAAA,QACV,SAAS;AAAA,QACT,OAAO;AAAA;IAEb,CAAG;AACD,UAAM,UAAU,QAAQ,MAAM,UAAU;AAAA,EAC1C;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/nand2tetris-hdl-B7HC94zZ.js

@@ -0,0 +1,51 @@
+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 nand2tetrisHdl_1;
+var hasRequiredNand2tetrisHdl;
+function requireNand2tetrisHdl() {
+  if (hasRequiredNand2tetrisHdl) return nand2tetrisHdl_1;
+  hasRequiredNand2tetrisHdl = 1;
+  nand2tetrisHdl_1 = nand2tetrisHdl2;
+  nand2tetrisHdl2.displayName = "nand2tetrisHdl";
+  nand2tetrisHdl2.aliases = [];
+  function nand2tetrisHdl2(Prism) {
+    Prism.languages["nand2tetris-hdl"] = {
+      comment: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
+      keyword: /\b(?:BUILTIN|CHIP|CLOCKED|IN|OUT|PARTS)\b/,
+      boolean: /\b(?:false|true)\b/,
+      function: /\b[A-Za-z][A-Za-z0-9]*(?=\()/,
+      number: /\b\d+\b/,
+      operator: /=|\.\./,
+      punctuation: /[{}[\];(),:]/
+    };
+  }
+  return nand2tetrisHdl_1;
+}
+var nand2tetrisHdlExports = requireNand2tetrisHdl();
+const nand2tetrisHdl = /* @__PURE__ */ getDefaultExportFromCjs(nand2tetrisHdlExports);
+const nand2tetrisHdl$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: nand2tetrisHdl
+}, [nand2tetrisHdlExports]);
+export {
+  nand2tetrisHdl$1 as n
+};
+//# sourceMappingURL=nand2tetris-hdl-B7HC94zZ.js.map

package/dist/nand2tetris-hdl-B7HC94zZ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nand2tetris-hdl-B7HC94zZ.js","sources":["../node_modules/refractor/lang/nand2tetris-hdl.js"],"sourcesContent":["'use strict'\n\nmodule.exports = nand2tetrisHdl\nnand2tetrisHdl.displayName = 'nand2tetrisHdl'\nnand2tetrisHdl.aliases = []\nfunction nand2tetrisHdl(Prism) {\n  Prism.languages['nand2tetris-hdl'] = {\n    comment: /\\/\\/.*|\\/\\*[\\s\\S]*?(?:\\*\\/|$)/,\n    keyword: /\\b(?:BUILTIN|CHIP|CLOCKED|IN|OUT|PARTS)\\b/,\n    boolean: /\\b(?:false|true)\\b/,\n    function: /\\b[A-Za-z][A-Za-z0-9]*(?=\\()/,\n    number: /\\b\\d+\\b/,\n    operator: /=|\\.\\./,\n    punctuation: /[{}[\\];(),:]/\n  }\n}\n"],"names":["nand2tetrisHdl"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,qBAAiBA;AACjB,EAAAA,gBAAe,cAAc;AAC7B,EAAAA,gBAAe,UAAU,CAAA;AACzB,WAASA,gBAAe,OAAO;AAC7B,UAAM,UAAU,iBAAiB,IAAI;AAAA,MACnC,SAAS;AAAA,MACT,SAAS;AAAA,MACT,SAAS;AAAA,MACT,UAAU;AAAA,MACV,QAAQ;AAAA,MACR,UAAU;AAAA,MACV,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/naniscript-CIypYI5Y.js

@@ -0,0 +1,190 @@
+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 naniscript_1;
+var hasRequiredNaniscript;
+function requireNaniscript() {
+  if (hasRequiredNaniscript) return naniscript_1;
+  hasRequiredNaniscript = 1;
+  naniscript_1 = naniscript2;
+  naniscript2.displayName = "naniscript";
+  naniscript2.aliases = [];
+  function naniscript2(Prism) {
+    (function(Prism2) {
+      var expressionDef = /\{[^\r\n\[\]{}]*\}/;
+      var params = {
+        "quoted-string": {
+          pattern: /"(?:[^"\\]|\\.)*"/,
+          alias: "operator"
+        },
+        "command-param-id": {
+          pattern: /(\s)\w+:/,
+          lookbehind: true,
+          alias: "property"
+        },
+        "command-param-value": [
+          {
+            pattern: expressionDef,
+            alias: "selector"
+          },
+          {
+            pattern: /([\t ])\S+/,
+            lookbehind: true,
+            greedy: true,
+            alias: "operator"
+          },
+          {
+            pattern: /\S(?:.*\S)?/,
+            alias: "operator"
+          }
+        ]
+      };
+      Prism2.languages.naniscript = {
+        // ; ...
+        comment: {
+          pattern: /^([\t ]*);.*/m,
+          lookbehind: true
+        },
+        // > ...
+        // Define is a control line starting with '>' followed by a word, a space and a text.
+        define: {
+          pattern: /^>.+/m,
+          alias: "tag",
+          inside: {
+            value: {
+              pattern: /(^>\w+[\t ]+)(?!\s)[^{}\r\n]+/,
+              lookbehind: true,
+              alias: "operator"
+            },
+            key: {
+              pattern: /(^>)\w+/,
+              lookbehind: true
+            }
+          }
+        },
+        // # ...
+        label: {
+          pattern: /^([\t ]*)#[\t ]*\w+[\t ]*$/m,
+          lookbehind: true,
+          alias: "regex"
+        },
+        command: {
+          pattern: /^([\t ]*)@\w+(?=[\t ]|$).*/m,
+          lookbehind: true,
+          alias: "function",
+          inside: {
+            "command-name": /^@\w+/,
+            expression: {
+              pattern: expressionDef,
+              greedy: true,
+              alias: "selector"
+            },
+            "command-params": {
+              pattern: /\s*\S[\s\S]*/,
+              inside: params
+            }
+          }
+        },
+        // Generic is any line that doesn't start with operators: ;>#@
+        "generic-text": {
+          pattern: /(^[ \t]*)[^#@>;\s].*/m,
+          lookbehind: true,
+          alias: "punctuation",
+          inside: {
+            // \{ ... \} ... \[ ... \] ... \"
+            "escaped-char": /\\[{}\[\]"]/,
+            expression: {
+              pattern: expressionDef,
+              greedy: true,
+              alias: "selector"
+            },
+            "inline-command": {
+              pattern: /\[[\t ]*\w[^\r\n\[\]]*\]/,
+              greedy: true,
+              alias: "function",
+              inside: {
+                "command-params": {
+                  pattern: /(^\[[\t ]*\w+\b)[\s\S]+(?=\]$)/,
+                  lookbehind: true,
+                  inside: params
+                },
+                "command-param-name": {
+                  pattern: /^(\[[\t ]*)\w+/,
+                  lookbehind: true,
+                  alias: "name"
+                },
+                "start-stop-char": /[\[\]]/
+              }
+            }
+          }
+        }
+      };
+      Prism2.languages.nani = Prism2.languages["naniscript"];
+      Prism2.hooks.add("after-tokenize", function(env) {
+        var tokens = env.tokens;
+        tokens.forEach(function(token) {
+          if (typeof token !== "string" && token.type === "generic-text") {
+            var content = getTextContent(token);
+            if (!isBracketsBalanced(content)) {
+              token.type = "bad-line";
+              token.content = content;
+            }
+          }
+        });
+      });
+      function isBracketsBalanced(input) {
+        var brackets = "[]{}";
+        var stack = [];
+        for (var i = 0; i < input.length; i++) {
+          var bracket = input[i];
+          var bracketsIndex = brackets.indexOf(bracket);
+          if (bracketsIndex !== -1) {
+            if (bracketsIndex % 2 === 0) {
+              stack.push(bracketsIndex + 1);
+            } else if (stack.pop() !== bracketsIndex) {
+              return false;
+            }
+          }
+        }
+        return stack.length === 0;
+      }
+      function getTextContent(token) {
+        if (typeof token === "string") {
+          return token;
+        } else if (Array.isArray(token)) {
+          return token.map(getTextContent).join("");
+        } else {
+          return getTextContent(token.content);
+        }
+      }
+    })(Prism);
+  }
+  return naniscript_1;
+}
+var naniscriptExports = requireNaniscript();
+const naniscript = /* @__PURE__ */ getDefaultExportFromCjs(naniscriptExports);
+const naniscript$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: naniscript
+}, [naniscriptExports]);
+export {
+  naniscript$1 as n
+};
+//# sourceMappingURL=naniscript-CIypYI5Y.js.map

package/dist/naniscript-CIypYI5Y.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"naniscript-CIypYI5Y.js","sources":["../node_modules/refractor/lang/naniscript.js"],"sourcesContent":["'use strict'\n\nmodule.exports = naniscript\nnaniscript.displayName = 'naniscript'\nnaniscript.aliases = []\nfunction naniscript(Prism) {\n  ;(function (Prism) {\n    var expressionDef = /\\{[^\\r\\n\\[\\]{}]*\\}/\n    var params = {\n      'quoted-string': {\n        pattern: /\"(?:[^\"\\\\]|\\\\.)*\"/,\n        alias: 'operator'\n      },\n      'command-param-id': {\n        pattern: /(\\s)\\w+:/,\n        lookbehind: true,\n        alias: 'property'\n      },\n      'command-param-value': [\n        {\n          pattern: expressionDef,\n          alias: 'selector'\n        },\n        {\n          pattern: /([\\t ])\\S+/,\n          lookbehind: true,\n          greedy: true,\n          alias: 'operator'\n        },\n        {\n          pattern: /\\S(?:.*\\S)?/,\n          alias: 'operator'\n        }\n      ]\n    }\n    Prism.languages.naniscript = {\n      // ; ...\n      comment: {\n        pattern: /^([\\t ]*);.*/m,\n        lookbehind: true\n      },\n      // > ...\n      // Define is a control line starting with '>' followed by a word, a space and a text.\n      define: {\n        pattern: /^>.+/m,\n        alias: 'tag',\n        inside: {\n          value: {\n            pattern: /(^>\\w+[\\t ]+)(?!\\s)[^{}\\r\\n]+/,\n            lookbehind: true,\n            alias: 'operator'\n          },\n          key: {\n            pattern: /(^>)\\w+/,\n            lookbehind: true\n          }\n        }\n      },\n      // # ...\n      label: {\n        pattern: /^([\\t ]*)#[\\t ]*\\w+[\\t ]*$/m,\n        lookbehind: true,\n        alias: 'regex'\n      },\n      command: {\n        pattern: /^([\\t ]*)@\\w+(?=[\\t ]|$).*/m,\n        lookbehind: true,\n        alias: 'function',\n        inside: {\n          'command-name': /^@\\w+/,\n          expression: {\n            pattern: expressionDef,\n            greedy: true,\n            alias: 'selector'\n          },\n          'command-params': {\n            pattern: /\\s*\\S[\\s\\S]*/,\n            inside: params\n          }\n        }\n      },\n      // Generic is any line that doesn't start with operators: ;>#@\n      'generic-text': {\n        pattern: /(^[ \\t]*)[^#@>;\\s].*/m,\n        lookbehind: true,\n        alias: 'punctuation',\n        inside: {\n          // \\{ ... \\} ... \\[ ... \\] ... \\\"\n          'escaped-char': /\\\\[{}\\[\\]\"]/,\n          expression: {\n            pattern: expressionDef,\n            greedy: true,\n            alias: 'selector'\n          },\n          'inline-command': {\n            pattern: /\\[[\\t ]*\\w[^\\r\\n\\[\\]]*\\]/,\n            greedy: true,\n            alias: 'function',\n            inside: {\n              'command-params': {\n                pattern: /(^\\[[\\t ]*\\w+\\b)[\\s\\S]+(?=\\]$)/,\n                lookbehind: true,\n                inside: params\n              },\n              'command-param-name': {\n                pattern: /^(\\[[\\t ]*)\\w+/,\n                lookbehind: true,\n                alias: 'name'\n              },\n              'start-stop-char': /[\\[\\]]/\n            }\n          }\n        }\n      }\n    }\n    Prism.languages.nani = Prism.languages['naniscript']\n    /** @typedef {InstanceType<import(\"./prism-core\")[\"Token\"]>} Token */\n    /**\n     * This hook is used to validate generic-text tokens for balanced brackets.\n     * Mark token as bad-line when contains not balanced brackets: {},[]\n     */\n    Prism.hooks.add('after-tokenize', function (env) {\n      /** @type {(Token | string)[]} */\n      var tokens = env.tokens\n      tokens.forEach(function (token) {\n        if (typeof token !== 'string' && token.type === 'generic-text') {\n          var content = getTextContent(token)\n          if (!isBracketsBalanced(content)) {\n            token.type = 'bad-line'\n            token.content = content\n          }\n        }\n      })\n    })\n    /**\n     * @param {string} input\n     * @returns {boolean}\n     */\n    function isBracketsBalanced(input) {\n      var brackets = '[]{}'\n      var stack = []\n      for (var i = 0; i < input.length; i++) {\n        var bracket = input[i]\n        var bracketsIndex = brackets.indexOf(bracket)\n        if (bracketsIndex !== -1) {\n          if (bracketsIndex % 2 === 0) {\n            stack.push(bracketsIndex + 1)\n          } else if (stack.pop() !== bracketsIndex) {\n            return false\n          }\n        }\n      }\n      return stack.length === 0\n    }\n    /**\n     * @param {string | Token | (string | Token)[]} token\n     * @returns {string}\n     */\n    function getTextContent(token) {\n      if (typeof token === 'string') {\n        return token\n      } else if (Array.isArray(token)) {\n        return token.map(getTextContent).join('')\n      } else {\n        return getTextContent(token.content)\n      }\n    }\n  })(Prism)\n}\n"],"names":["naniscript","Prism"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/nasm-DbAe9Bp_.js

@@ -0,0 +1,66 @@
+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 nasm_1;
+var hasRequiredNasm;
+function requireNasm() {
+  if (hasRequiredNasm) return nasm_1;
+  hasRequiredNasm = 1;
+  nasm_1 = nasm2;
+  nasm2.displayName = "nasm";
+  nasm2.aliases = [];
+  function nasm2(Prism) {
+    Prism.languages.nasm = {
+      comment: /;.*$/m,
+      string: /(["'`])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+      label: {
+        pattern: /(^\s*)[A-Za-z._?$][\w.?$@~#]*:/m,
+        lookbehind: true,
+        alias: "function"
+      },
+      keyword: [
+        /\[?BITS (?:16|32|64)\]?/,
+        {
+          pattern: /(^\s*)section\s*[a-z.]+:?/im,
+          lookbehind: true
+        },
+        /(?:extern|global)[^;\r\n]*/i,
+        /(?:CPU|DEFAULT|FLOAT).*$/m
+      ],
+      register: {
+        pattern: /\b(?:st\d|[xyz]mm\d\d?|[cdt]r\d|r\d\d?[bwd]?|[er]?[abcd]x|[abcd][hl]|[er]?(?:bp|di|si|sp)|[cdefgs]s)\b/i,
+        alias: "variable"
+      },
+      number: /(?:\b|(?=\$))(?:0[hx](?:\.[\da-f]+|[\da-f]+(?:\.[\da-f]+)?)(?:p[+-]?\d+)?|\d[\da-f]+[hx]|\$\d[\da-f]*|0[oq][0-7]+|[0-7]+[oq]|0[by][01]+|[01]+[by]|0[dt]\d+|(?:\d+(?:\.\d+)?|\.\d+)(?:\.?e[+-]?\d+)?[dt]?)\b/i,
+      operator: /[\[\]*+\-\/%<>=&|$!]/
+    };
+  }
+  return nasm_1;
+}
+var nasmExports = requireNasm();
+const nasm = /* @__PURE__ */ getDefaultExportFromCjs(nasmExports);
+const nasm$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: nasm
+}, [nasmExports]);
+export {
+  nasm$1 as n
+};
+//# sourceMappingURL=nasm-DbAe9Bp_.js.map

package/dist/nasm-DbAe9Bp_.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nasm-DbAe9Bp_.js","sources":["../node_modules/refractor/lang/nasm.js"],"sourcesContent":["'use strict'\n\nmodule.exports = nasm\nnasm.displayName = 'nasm'\nnasm.aliases = []\nfunction nasm(Prism) {\n  Prism.languages.nasm = {\n    comment: /;.*$/m,\n    string: /([\"'`])(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/,\n    label: {\n      pattern: /(^\\s*)[A-Za-z._?$][\\w.?$@~#]*:/m,\n      lookbehind: true,\n      alias: 'function'\n    },\n    keyword: [\n      /\\[?BITS (?:16|32|64)\\]?/,\n      {\n        pattern: /(^\\s*)section\\s*[a-z.]+:?/im,\n        lookbehind: true\n      },\n      /(?:extern|global)[^;\\r\\n]*/i,\n      /(?:CPU|DEFAULT|FLOAT).*$/m\n    ],\n    register: {\n      pattern:\n        /\\b(?:st\\d|[xyz]mm\\d\\d?|[cdt]r\\d|r\\d\\d?[bwd]?|[er]?[abcd]x|[abcd][hl]|[er]?(?:bp|di|si|sp)|[cdefgs]s)\\b/i,\n      alias: 'variable'\n    },\n    number:\n      /(?:\\b|(?=\\$))(?:0[hx](?:\\.[\\da-f]+|[\\da-f]+(?:\\.[\\da-f]+)?)(?:p[+-]?\\d+)?|\\d[\\da-f]+[hx]|\\$\\d[\\da-f]*|0[oq][0-7]+|[0-7]+[oq]|0[by][01]+|[01]+[by]|0[dt]\\d+|(?:\\d+(?:\\.\\d+)?|\\.\\d+)(?:\\.?e[+-]?\\d+)?[dt]?)\\b/i,\n    operator: /[\\[\\]*+\\-\\/%<>=&|$!]/\n  }\n}\n"],"names":["nasm"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AACnB,UAAM,UAAU,OAAO;AAAA,MACrB,SAAS;AAAA,MACT,QAAQ;AAAA,MACR,OAAO;AAAA,QACL,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA;MAET,SAAS;AAAA,QACP;AAAA,QACA;AAAA,UACE,SAAS;AAAA,UACT,YAAY;AAAA;QAEd;AAAA,QACA;AAAA;MAEF,UAAU;AAAA,QACR,SACE;AAAA,QACF,OAAO;AAAA;MAET,QACE;AAAA,MACF,UAAU;AAAA;EAEd;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/neon-ETXY_3sS.js

@@ -0,0 +1,82 @@
+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 neon_1;
+var hasRequiredNeon;
+function requireNeon() {
+  if (hasRequiredNeon) return neon_1;
+  hasRequiredNeon = 1;
+  neon_1 = neon2;
+  neon2.displayName = "neon";
+  neon2.aliases = [];
+  function neon2(Prism) {
+    Prism.languages.neon = {
+      comment: {
+        pattern: /#.*/,
+        greedy: true
+      },
+      datetime: {
+        pattern: /(^|[[{(=:,\s])\d\d\d\d-\d\d?-\d\d?(?:(?:[Tt]| +)\d\d?:\d\d:\d\d(?:\.\d*)? *(?:Z|[-+]\d\d?(?::?\d\d)?)?)?(?=$|[\]}),\s])/,
+        lookbehind: true,
+        alias: "number"
+      },
+      key: {
+        pattern: /(^|[[{(,\s])[^,:=[\]{}()'"\s]+(?=\s*:(?:$|[\]}),\s])|\s*=)/,
+        lookbehind: true,
+        alias: "atrule"
+      },
+      number: {
+        pattern: /(^|[[{(=:,\s])[+-]?(?:0x[\da-fA-F]+|0o[0-7]+|0b[01]+|(?:\d+(?:\.\d*)?|\.?\d+)(?:[eE][+-]?\d+)?)(?=$|[\]}),:=\s])/,
+        lookbehind: true
+      },
+      boolean: {
+        pattern: /(^|[[{(=:,\s])(?:false|no|true|yes)(?=$|[\]}),:=\s])/i,
+        lookbehind: true
+      },
+      null: {
+        pattern: /(^|[[{(=:,\s])(?:null)(?=$|[\]}),:=\s])/i,
+        lookbehind: true,
+        alias: "keyword"
+      },
+      string: {
+        pattern: /(^|[[{(=:,\s])(?:('''|""")\r?\n(?:(?:[^\r\n]|\r?\n(?![\t ]*\2))*\r?\n)?[\t ]*\2|'[^'\r\n]*'|"(?:\\.|[^\\"\r\n])*")/,
+        lookbehind: true,
+        greedy: true
+      },
+      literal: {
+        pattern: /(^|[[{(=:,\s])(?:[^#"',:=[\]{}()\s`-]|[:-][^"',=[\]{}()\s])(?:[^,:=\]})(\s]|:(?![\s,\]})]|$)|[ \t]+[^#,:=\]})(\s])*/,
+        lookbehind: true,
+        alias: "string"
+      },
+      punctuation: /[,:=[\]{}()-]/
+    };
+  }
+  return neon_1;
+}
+var neonExports = requireNeon();
+const neon = /* @__PURE__ */ getDefaultExportFromCjs(neonExports);
+const neon$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: neon
+}, [neonExports]);
+export {
+  neon$1 as n
+};
+//# sourceMappingURL=neon-ETXY_3sS.js.map