@photonix/basic 1.5.0 → 1.6.0

package/dist/chunk-42DSMFYZ.mjs

@@ -0,0 +1,116 @@
+import {
+  clike
+} from "./chunk-XWTEQUC3.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/qsharp.js
+qsharp.displayName = "qsharp";
+qsharp.aliases = ["qs"];
+function qsharp(Prism) {
+  Prism.register(clike);
+  (function(Prism2) {
+    function replace(pattern, replacements) {
+      return pattern.replace(/<<(\d+)>>/g, function(m, index) {
+        return "(?:" + replacements[+index] + ")";
+      });
+    }
+    function re(pattern, replacements, flags) {
+      return RegExp(replace(pattern, replacements), flags || "");
+    }
+    function nested(pattern, depthLog2) {
+      for (var i = 0; i < depthLog2; i++) {
+        pattern = pattern.replace(/<<self>>/g, function() {
+          return "(?:" + pattern + ")";
+        });
+      }
+      return pattern.replace(/<<self>>/g, "[^\\s\\S]");
+    }
+    var keywordKinds = {
+      // keywords which represent a return or variable type
+      type: "Adj BigInt Bool Ctl Double false Int One Pauli PauliI PauliX PauliY PauliZ Qubit Range Result String true Unit Zero",
+      // all other keywords
+      other: "Adjoint adjoint apply as auto body borrow borrowing Controlled controlled distribute elif else fail fixup for function if in internal intrinsic invert is let mutable namespace new newtype open operation repeat return self set until use using while within"
+    };
+    function keywordsToPattern(words) {
+      return "\\b(?:" + words.trim().replace(/ /g, "|") + ")\\b";
+    }
+    var keywords = RegExp(
+      keywordsToPattern(keywordKinds.type + " " + keywordKinds.other)
+    );
+    var identifier = /\b[A-Za-z_]\w*\b/.source;
+    var qualifiedName = replace(/<<0>>(?:\s*\.\s*<<0>>)*/.source, [identifier]);
+    var typeInside = {
+      keyword: keywords,
+      punctuation: /[<>()?,.:[\]]/
+    };
+    var regularString = /"(?:\\.|[^\\"])*"/.source;
+    Prism2.languages.qsharp = Prism2.languages.extend("clike", {
+      comment: /\/\/.*/,
+      string: [
+        {
+          pattern: re(/(^|[^$\\])<<0>>/.source, [regularString]),
+          lookbehind: true,
+          greedy: true
+        }
+      ],
+      "class-name": [
+        {
+          // open Microsoft.Quantum.Canon;
+          // open Microsoft.Quantum.Canon as CN;
+          pattern: re(/(\b(?:as|open)\s+)<<0>>(?=\s*(?:;|as\b))/.source, [
+            qualifiedName
+          ]),
+          lookbehind: true,
+          inside: typeInside
+        },
+        {
+          // namespace Quantum.App1;
+          pattern: re(/(\bnamespace\s+)<<0>>(?=\s*\{)/.source, [qualifiedName]),
+          lookbehind: true,
+          inside: typeInside
+        }
+      ],
+      keyword: keywords,
+      number: /(?:\b0(?:x[\da-f]+|b[01]+|o[0-7]+)|(?:\B\.\d+|\b\d+(?:\.\d*)?)(?:e[-+]?\d+)?)l?\b/i,
+      operator: /\band=|\bor=|\band\b|\bnot\b|\bor\b|<[-=]|[-=]>|>>>=?|<<<=?|\^\^\^=?|\|\|\|=?|&&&=?|w\/=?|~~~|[*\/+\-^=!%]=?/,
+      punctuation: /::|[{}[\];(),.:]/
+    });
+    Prism2.languages.insertBefore("qsharp", "number", {
+      range: {
+        pattern: /\.\./,
+        alias: "operator"
+      }
+    });
+    var interpolationExpr = nested(
+      replace(/\{(?:[^"{}]|<<0>>|<<self>>)*\}/.source, [regularString]),
+      2
+    );
+    Prism2.languages.insertBefore("qsharp", "string", {
+      "interpolation-string": {
+        pattern: re(/\$"(?:\\.|<<0>>|[^\\"{])*"/.source, [interpolationExpr]),
+        greedy: true,
+        inside: {
+          interpolation: {
+            pattern: re(/((?:^|[^\\])(?:\\\\)*)<<0>>/.source, [
+              interpolationExpr
+            ]),
+            lookbehind: true,
+            inside: {
+              punctuation: /^\{|\}$/,
+              expression: {
+                pattern: /[\s\S]+/,
+                alias: "language-qsharp",
+                inside: Prism2.languages.qsharp
+              }
+            }
+          },
+          string: /[\s\S]+/
+        }
+      }
+    });
+  })(Prism);
+  Prism.languages.qs = Prism.languages.qsharp;
+}
+
+export {
+  qsharp
+};

package/dist/chunk-4BJPBRSO.mjs

@@ -0,0 +1,68 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/inform7.js
+inform7.displayName = "inform7";
+inform7.aliases = [];
+function inform7(Prism) {
+  Prism.languages.inform7 = {
+    string: {
+      pattern: /"[^"]*"/,
+      inside: {
+        substitution: {
+          pattern: /\[[^\[\]]+\]/,
+          inside: {
+            delimiter: {
+              pattern: /\[|\]/,
+              alias: "punctuation"
+            }
+            // See rest below
+          }
+        }
+      }
+    },
+    comment: {
+      pattern: /\[[^\[\]]+\]/,
+      greedy: true
+    },
+    title: {
+      pattern: /^[ \t]*(?:book|chapter|part(?! of)|section|table|volume)\b.+/im,
+      alias: "important"
+    },
+    number: {
+      pattern: /(^|[^-])(?:\b\d+(?:\.\d+)?(?:\^\d+)?(?:(?!\d)\w+)?|\b(?:eight|eleven|five|four|nine|one|seven|six|ten|three|twelve|two))\b(?!-)/i,
+      lookbehind: true
+    },
+    verb: {
+      pattern: /(^|[^-])\b(?:answering|applying to|are|asking|attacking|be(?:ing)?|burning|buying|called|carries|carry(?! out)|carrying|climbing|closing|conceal(?:ing|s)?|consulting|contain(?:ing|s)?|cutting|drinking|dropping|eating|enclos(?:es?|ing)|entering|examining|exiting|getting|giving|going|ha(?:s|ve|ving)|hold(?:ing|s)?|impl(?:ies|y)|incorporat(?:es?|ing)|inserting|is|jumping|kissing|listening|locking|looking|mean(?:ing|s)?|opening|provid(?:es?|ing)|pulling|pushing|putting|relat(?:es?|ing)|removing|searching|see(?:ing|s)?|setting|showing|singing|sleeping|smelling|squeezing|support(?:ing|s)?|swearing|switching|taking|tasting|telling|thinking|throwing|touching|turning|tying|unlock(?:ing|s)?|var(?:ies|y|ying)|waiting|waking|waving|wear(?:ing|s)?)\b(?!-)/i,
+      lookbehind: true,
+      alias: "operator"
+    },
+    keyword: {
+      pattern: /(^|[^-])\b(?:after|before|carry out|check|continue the action|definition(?= *:)|do nothing|else|end (?:if|the story|unless)|every turn|if|include|instead(?: of)?|let|move|no|now|otherwise|repeat|report|resume the story|rule for|running through|say(?:ing)?|stop the action|test|try(?:ing)?|understand|unless|use|when|while|yes)\b(?!-)/i,
+      lookbehind: true
+    },
+    property: {
+      pattern: /(^|[^-])\b(?:adjacent(?! to)|carried|closed|concealed|contained|dark|described|edible|empty|enclosed|enterable|even|female|fixed in place|full|handled|held|improper-named|incorporated|inedible|invisible|lighted|lit|lock(?:able|ed)|male|marked for listing|mentioned|negative|neuter|non-(?:empty|full|recurring)|odd|opaque|open(?:able)?|plural-named|portable|positive|privately-named|proper-named|provided|publically-named|pushable between rooms|recurring|related|rubbing|scenery|seen|singular-named|supported|swinging|switch(?:able|ed(?: off| on)?)|touch(?:able|ed)|transparent|unconcealed|undescribed|unlit|unlocked|unmarked for listing|unmentioned|unopenable|untouchable|unvisited|variable|visible|visited|wearable|worn)\b(?!-)/i,
+      lookbehind: true,
+      alias: "symbol"
+    },
+    position: {
+      pattern: /(^|[^-])\b(?:above|adjacent to|back side of|below|between|down|east|everywhere|front side|here|in|inside(?: from)?|north(?:east|west)?|nowhere|on(?: top of)?|other side|outside(?: from)?|parts? of|regionally in|south(?:east|west)?|through|up|west|within)\b(?!-)/i,
+      lookbehind: true,
+      alias: "keyword"
+    },
+    type: {
+      pattern: /(^|[^-])\b(?:actions?|activit(?:ies|y)|actors?|animals?|backdrops?|containers?|devices?|directions?|doors?|holders?|kinds?|lists?|m[ae]n|nobody|nothing|nouns?|numbers?|objects?|people|persons?|player(?:'s holdall)?|regions?|relations?|rooms?|rule(?:book)?s?|scenes?|someone|something|supporters?|tables?|texts?|things?|time|vehicles?|wom[ae]n)\b(?!-)/i,
+      lookbehind: true,
+      alias: "variable"
+    },
+    punctuation: /[.,:;(){}]/
+  };
+  Prism.languages.inform7["string"].inside["substitution"].inside.rest = Prism.languages.inform7;
+  Prism.languages.inform7["string"].inside["substitution"].inside.rest.text = {
+    pattern: /\S(?:\s*\S)*/,
+    alias: "comment"
+  };
+}
+
+export {
+  inform7
+};

package/dist/chunk-4F6TSYBP.mjs

@@ -0,0 +1,42 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/sql.js
+sql.displayName = "sql";
+sql.aliases = [];
+function sql(Prism) {
+  Prism.languages.sql = {
+    comment: {
+      pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/,
+      lookbehind: true
+    },
+    variable: [
+      {
+        pattern: /@(["'`])(?:\\[\s\S]|(?!\1)[^\\])+\1/,
+        greedy: true
+      },
+      /@[\w.$]+/
+    ],
+    string: {
+      pattern: /(^|[^@\\])("|')(?:\\[\s\S]|(?!\2)[^\\]|\2\2)*\2/,
+      greedy: true,
+      lookbehind: true
+    },
+    identifier: {
+      pattern: /(^|[^@\\])`(?:\\[\s\S]|[^`\\]|``)*`/,
+      greedy: true,
+      lookbehind: true,
+      inside: {
+        punctuation: /^`|`$/
+      }
+    },
+    function: /\b(?:AVG|COUNT|FIRST|FORMAT|LAST|LCASE|LEN|MAX|MID|MIN|MOD|NOW|ROUND|SUM|UCASE)(?=\s*\()/i,
+    // Should we highlight user defined functions too?
+    keyword: /\b(?:ACTION|ADD|AFTER|ALGORITHM|ALL|ALTER|ANALYZE|ANY|APPLY|AS|ASC|AUTHORIZATION|AUTO_INCREMENT|BACKUP|BDB|BEGIN|BERKELEYDB|BIGINT|BINARY|BIT|BLOB|BOOL|BOOLEAN|BREAK|BROWSE|BTREE|BULK|BY|CALL|CASCADED?|CASE|CHAIN|CHAR(?:ACTER|SET)?|CHECK(?:POINT)?|CLOSE|CLUSTERED|COALESCE|COLLATE|COLUMNS?|COMMENT|COMMIT(?:TED)?|COMPUTE|CONNECT|CONSISTENT|CONSTRAINT|CONTAINS(?:TABLE)?|CONTINUE|CONVERT|CREATE|CROSS|CURRENT(?:_DATE|_TIME|_TIMESTAMP|_USER)?|CURSOR|CYCLE|DATA(?:BASES?)?|DATE(?:TIME)?|DAY|DBCC|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFINER|DELAYED|DELETE|DELIMITERS?|DENY|DESC|DESCRIBE|DETERMINISTIC|DISABLE|DISCARD|DISK|DISTINCT|DISTINCTROW|DISTRIBUTED|DO|DOUBLE|DROP|DUMMY|DUMP(?:FILE)?|DUPLICATE|ELSE(?:IF)?|ENABLE|ENCLOSED|END|ENGINE|ENUM|ERRLVL|ERRORS|ESCAPED?|EXCEPT|EXEC(?:UTE)?|EXISTS|EXIT|EXPLAIN|EXTENDED|FETCH|FIELDS|FILE|FILLFACTOR|FIRST|FIXED|FLOAT|FOLLOWING|FOR(?: EACH ROW)?|FORCE|FOREIGN|FREETEXT(?:TABLE)?|FROM|FULL|FUNCTION|GEOMETRY(?:COLLECTION)?|GLOBAL|GOTO|GRANT|GROUP|HANDLER|HASH|HAVING|HOLDLOCK|HOUR|IDENTITY(?:COL|_INSERT)?|IF|IGNORE|IMPORT|INDEX|INFILE|INNER|INNODB|INOUT|INSERT|INT|INTEGER|INTERSECT|INTERVAL|INTO|INVOKER|ISOLATION|ITERATE|JOIN|KEYS?|KILL|LANGUAGE|LAST|LEAVE|LEFT|LEVEL|LIMIT|LINENO|LINES|LINESTRING|LOAD|LOCAL|LOCK|LONG(?:BLOB|TEXT)|LOOP|MATCH(?:ED)?|MEDIUM(?:BLOB|INT|TEXT)|MERGE|MIDDLEINT|MINUTE|MODE|MODIFIES|MODIFY|MONTH|MULTI(?:LINESTRING|POINT|POLYGON)|NATIONAL|NATURAL|NCHAR|NEXT|NO|NONCLUSTERED|NULLIF|NUMERIC|OFF?|OFFSETS?|ON|OPEN(?:DATASOURCE|QUERY|ROWSET)?|OPTIMIZE|OPTION(?:ALLY)?|ORDER|OUT(?:ER|FILE)?|OVER|PARTIAL|PARTITION|PERCENT|PIVOT|PLAN|POINT|POLYGON|PRECEDING|PRECISION|PREPARE|PREV|PRIMARY|PRINT|PRIVILEGES|PROC(?:EDURE)?|PUBLIC|PURGE|QUICK|RAISERROR|READS?|REAL|RECONFIGURE|REFERENCES|RELEASE|RENAME|REPEAT(?:ABLE)?|REPLACE|REPLICATION|REQUIRE|RESIGNAL|RESTORE|RESTRICT|RETURN(?:ING|S)?|REVOKE|RIGHT|ROLLBACK|ROUTINE|ROW(?:COUNT|GUIDCOL|S)?|RTREE|RULE|SAVE(?:POINT)?|SCHEMA|SECOND|SELECT|SERIAL(?:IZABLE)?|SESSION(?:_USER)?|SET(?:USER)?|SHARE|SHOW|SHUTDOWN|SIMPLE|SMALLINT|SNAPSHOT|SOME|SONAME|SQL|START(?:ING)?|STATISTICS|STATUS|STRIPED|SYSTEM_USER|TABLES?|TABLESPACE|TEMP(?:ORARY|TABLE)?|TERMINATED|TEXT(?:SIZE)?|THEN|TIME(?:STAMP)?|TINY(?:BLOB|INT|TEXT)|TOP?|TRAN(?:SACTIONS?)?|TRIGGER|TRUNCATE|TSEQUAL|TYPES?|UNBOUNDED|UNCOMMITTED|UNDEFINED|UNION|UNIQUE|UNLOCK|UNPIVOT|UNSIGNED|UPDATE(?:TEXT)?|USAGE|USE|USER|USING|VALUES?|VAR(?:BINARY|CHAR|CHARACTER|YING)|VIEW|WAITFOR|WARNINGS|WHEN|WHERE|WHILE|WITH(?: ROLLUP|IN)?|WORK|WRITE(?:TEXT)?|YEAR)\b/i,
+    boolean: /\b(?:FALSE|NULL|TRUE)\b/i,
+    number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i,
+    operator: /[-+*\/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?|\b(?:AND|BETWEEN|DIV|ILIKE|IN|IS|LIKE|NOT|OR|REGEXP|RLIKE|SOUNDS LIKE|XOR)\b/i,
+    punctuation: /[;[\]()`,.]/
+  };
+}
+
+export {
+  sql
+};

package/dist/chunk-4FONECRJ.mjs

@@ -0,0 +1,107 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/wgsl.js
+wgsl.displayName = "wgsl";
+wgsl.aliases = [];
+function wgsl(Prism) {
+  Prism.languages.wgsl = {
+    comment: {
+      pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
+      greedy: true
+    },
+    "builtin-attribute": {
+      pattern: /(@)builtin\(.*?\)/,
+      lookbehind: true,
+      inside: {
+        attribute: {
+          pattern: /^builtin/,
+          alias: "attr-name"
+        },
+        punctuation: /[(),]/,
+        "built-in-values": {
+          pattern: /\b(?:frag_depth|front_facing|global_invocation_id|instance_index|local_invocation_id|local_invocation_index|num_workgroups|position|sample_index|sample_mask|vertex_index|workgroup_id)\b/,
+          alias: "attr-value"
+        }
+      }
+    },
+    attributes: {
+      pattern: /(@)(?:align|binding|compute|const|fragment|group|id|interpolate|invariant|location|size|vertex|workgroup_size)/i,
+      lookbehind: true,
+      alias: "attr-name"
+    },
+    functions: {
+      pattern: /\b(fn\s+)[_a-zA-Z]\w*(?=[(<])/,
+      lookbehind: true,
+      alias: "function"
+    },
+    keyword: /\b(?:bitcast|break|case|const|continue|continuing|default|discard|else|enable|fallthrough|fn|for|function|if|let|loop|private|return|storage|struct|switch|type|uniform|var|while|workgroup)\b/,
+    builtin: /\b(?:abs|acos|acosh|all|any|array|asin|asinh|atan|atan2|atanh|atomic|atomicAdd|atomicAnd|atomicCompareExchangeWeak|atomicExchange|atomicLoad|atomicMax|atomicMin|atomicOr|atomicStore|atomicSub|atomicXor|bool|ceil|clamp|cos|cosh|countLeadingZeros|countOneBits|countTrailingZeros|cross|degrees|determinant|distance|dot|dpdx|dpdxCoarse|dpdxFine|dpdy|dpdyCoarse|dpdyFine|exp|exp2|extractBits|f32|f64|faceForward|firstLeadingBit|floor|fma|fract|frexp|fwidth|fwidthCoarse|fwidthFine|i32|i64|insertBits|inverseSqrt|ldexp|length|log|log2|mat[2-4]x[2-4]|max|min|mix|modf|normalize|override|pack2x16float|pack2x16snorm|pack2x16unorm|pack4x8snorm|pack4x8unorm|pow|ptr|quantizeToF16|radians|reflect|refract|reverseBits|round|sampler|sampler_comparison|select|shiftLeft|shiftRight|sign|sin|sinh|smoothstep|sqrt|staticAssert|step|storageBarrier|tan|tanh|textureDimensions|textureGather|textureGatherCompare|textureLoad|textureNumLayers|textureNumLevels|textureNumSamples|textureSample|textureSampleBias|textureSampleCompare|textureSampleCompareLevel|textureSampleGrad|textureSampleLevel|textureStore|texture_1d|texture_2d|texture_2d_array|texture_3d|texture_cube|texture_cube_array|texture_depth_2d|texture_depth_2d_array|texture_depth_cube|texture_depth_cube_array|texture_depth_multisampled_2d|texture_multisampled_2d|texture_storage_1d|texture_storage_2d|texture_storage_2d_array|texture_storage_3d|transpose|trunc|u32|u64|unpack2x16float|unpack2x16snorm|unpack2x16unorm|unpack4x8snorm|unpack4x8unorm|vec[2-4]|workgroupBarrier)\b/,
+    "function-calls": {
+      pattern: /\b[_a-z]\w*(?=\()/i,
+      alias: "function"
+    },
+    "class-name": /\b(?:[A-Z][A-Za-z0-9]*)\b/,
+    "bool-literal": {
+      pattern: /\b(?:false|true)\b/,
+      alias: "boolean"
+    },
+    "hex-int-literal": {
+      pattern: /\b0[xX][0-9a-fA-F]+[iu]?\b(?![.pP])/,
+      alias: "number"
+    },
+    "hex-float-literal": {
+      pattern: /\b0[xX][0-9a-fA-F]*(?:\.[0-9a-fA-F]*)?(?:[pP][+-]?\d+[fh]?)?/,
+      alias: "number"
+    },
+    "decimal-float-literal": [
+      {
+        pattern: /\d*\.\d+(?:[eE](?:\+|-)?\d+)?[fh]?/,
+        alias: "number"
+      },
+      {
+        pattern: /\d+\.\d*(?:[eE](?:\+|-)?\d+)?[fh]?/,
+        alias: "number"
+      },
+      {
+        pattern: /\d+[eE](?:\+|-)?\d+[fh]?/,
+        alias: "number"
+      },
+      {
+        pattern: /\b\d+[fh]\b/,
+        alias: "number"
+      }
+    ],
+    "int-literal": {
+      pattern: /\b\d+[iu]?\b/,
+      alias: "number"
+    },
+    operator: [
+      {
+        pattern: /(?:\^|~|\|(?!\|)|\|\||&&|<<|>>|!)(?!=)/
+      },
+      {
+        pattern: /&(?![&=])/
+      },
+      {
+        pattern: /(?:\+=|-=|\*=|\/=|%=|\^=|&=|\|=|<<=|>>=)/
+      },
+      {
+        pattern: /(^|[^<>=!])=(?![=>])/,
+        lookbehind: true
+      },
+      {
+        pattern: /(?:==|!=|<=|\+\+|--|(^|[^=])>=)/,
+        lookbehind: true
+      },
+      {
+        pattern: /(?:(?:[+%]|(?:\*(?!\w)))(?!=))|(?:-(?!>))|(?:\/(?!\/))/
+      },
+      {
+        pattern: /->/
+      }
+    ],
+    punctuation: /[@(){}[\],;<>:.]/
+  };
+}
+
+export {
+  wgsl
+};

package/dist/chunk-4KT62F5C.mjs

@@ -0,0 +1,37 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/false.js
+$false.displayName = "false";
+$false.aliases = [];
+function $false(Prism) {
+  ;
+  (function(Prism2) {
+    Prism2.languages["false"] = {
+      comment: {
+        pattern: /\{[^}]*\}/
+      },
+      string: {
+        pattern: /"[^"]*"/,
+        greedy: true
+      },
+      "character-code": {
+        pattern: /'(?:[^\r]|\r\n?)/,
+        alias: "number"
+      },
+      "assembler-code": {
+        pattern: /\d+`/,
+        alias: "important"
+      },
+      number: /\d+/,
+      operator: /[-!#$%&'*+,./:;=>?@\\^_`|~ßø]/,
+      punctuation: /\[|\]/,
+      variable: /[a-z]/,
+      "non-standard": {
+        pattern: /[()<BDO®]/,
+        alias: "bold"
+      }
+    };
+  })(Prism);
+}
+
+export {
+  $false
+};

package/dist/chunk-4N5NQVL3.mjs

@@ -0,0 +1,29 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/ebnf.js
+ebnf.displayName = "ebnf";
+ebnf.aliases = [];
+function ebnf(Prism) {
+  Prism.languages.ebnf = {
+    comment: /\(\*[\s\S]*?\*\)/,
+    string: {
+      pattern: /"[^"\r\n]*"|'[^'\r\n]*'/,
+      greedy: true
+    },
+    special: {
+      pattern: /\?[^?\r\n]*\?/,
+      greedy: true,
+      alias: "class-name"
+    },
+    definition: {
+      pattern: /^([\t ]*)[a-z]\w*(?:[ \t]+[a-z]\w*)*(?=\s*=)/im,
+      lookbehind: true,
+      alias: ["rule", "keyword"]
+    },
+    rule: /\b[a-z]\w*(?:[ \t]+[a-z]\w*)*\b/i,
+    punctuation: /\([:/]|[:/]\)|[.,;()[\]{}]/,
+    operator: /[-=|*/!]/
+  };
+}
+
+export {
+  ebnf
+};

package/dist/chunk-4PL2CJJ3.mjs

@@ -0,0 +1,49 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/neon.js
+neon.displayName = "neon";
+neon.aliases = [];
+function neon(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: "property"
+    },
+    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: /[,:=[\]{}()-]/
+  };
+}
+
+export {
+  neon
+};