comarkserv 0.1.0

package/dist/dist-ByijHttv.mjs

@@ -0,0 +1,69 @@
+import { A as Wr, F as Zr, G as ge, M as Xr, S as Qr, V as ei, et as qn, m as Kr, mt as g$1, pt as _$1, s as Gr, tt as qr, u as Hr } from "./twinkleplop.production-DekYmX6O.mjs";
+import { F as c, G as i, nt as o, s as Fe, z as e } from "./twinkleplop.tokens-CgBUTCSg.mjs";
+//#region node_modules/.pnpm/@twinkleplop+json@0.1.4/node_modules/@twinkleplop/json/dist/index.js
+var m = g$1({
+	name: "json",
+	states: {
+		main: { rules: [
+			Zr([
+				" ",
+				"	",
+				"\n",
+				"\r"
+			]),
+			Xr("\"", c, Gr("string_body")),
+			Qr(["true", "false"], {}, e),
+			Qr(["null"]),
+			Xr([
+				"{",
+				"}",
+				"[",
+				"]",
+				",",
+				":"
+			], o),
+			Xr("-", i, Gr("negative_number")),
+			Xr(Hr, i, Gr("number"))
+		] },
+		negative_number: { rules: [Xr(Hr, i, Kr("number")), ei(qr())] },
+		number: { rules: [
+			Xr(Hr, i),
+			Xr(".", i, Kr("decimal")),
+			Xr(["e", "E"], i, Kr("exponent_sign")),
+			ei(qr())
+		] },
+		decimal: { rules: [
+			Xr(Hr, i),
+			Xr(["e", "E"], i, Kr("exponent_sign")),
+			ei(qr())
+		] },
+		exponent_sign: { rules: [
+			Xr(["+", "-"], i, Kr("exponent_digits")),
+			Xr(Hr, i, Kr("exponent_digits")),
+			ei(qr())
+		] },
+		exponent_digits: { rules: [Xr(Hr, i), ei(qr())] },
+		string_body: { rules: [
+			Xr("\\", Fe, Gr("string_escape_start")),
+			Xr("\"", c, qr()),
+			ei({ token: c })
+		] },
+		string_escape_start: { rules: [Xr("u", Fe, Kr("esc_u4_d1")), ei({
+			token: Fe,
+			exit: !0
+		})] },
+		esc_u4_d1: { rules: [Xr(Wr, Fe, Kr("esc_u4_d2")), ei(qr())] },
+		esc_u4_d2: { rules: [Xr(Wr, Fe, Kr("esc_u4_d3")), ei(qr())] },
+		esc_u4_d3: { rules: [Xr(Wr, Fe, Kr("esc_u4_d4")), ei(qr())] },
+		esc_u4_d4: { rules: [Xr(Wr, Fe, qr()), ei(qr())] }
+	}
+});
+var h = _$1(m);
+var g = [];
+var _ = qn(h, g);
+function v(e) {
+	let t = _(e);
+	return (e, n) => ge(e, t(e), n);
+}
+//#endregion
+export { h as grammar, v as language, m as raw_grammar, g as reclassifiers, _ as tokenize };

package/dist/dist-C2E4zSX1.mjs

@@ -0,0 +1,347 @@
+import { A as Wr, F as Zr, G as ge, M as Xr, O as Vn, V as ei, d as Ir, et as qn, h as Lr, k as Vr, m as Kr, mt as g, pt as _, r as $r, s as Gr, tt as qr, u as Hr } from "./twinkleplop.production-DekYmX6O.mjs";
+import { F as c, G as i, N as b$1, et as n, j as a, nt as o, s as Fe, ut as t } from "./twinkleplop.tokens-CgBUTCSg.mjs";
+//#region node_modules/.pnpm/@twinkleplop+sql@0.1.4/node_modules/@twinkleplop/sql/dist/index.js
+var v = /* @__PURE__ */ "<=>.!~*.->>.#>>.!=.<=.>=.<>.::.->.#>.@>.<@.||.&&.!~.~*.?|.?&.+=.-=.*=./=.%=.&=.|=.^=.!<.!>.==.**.<<.>>.:=.@@.+.-.*./.%.^.=.<.>.!.~.&.|".split(".");
+var y = Zr([
+	" ",
+	"	",
+	"\n",
+	"\r"
+]);
+var b = $r("--", "\n", t);
+var x = $r("#", "\n", t);
+var S = Lr([
+	["a", "z"],
+	["A", "Z"],
+	["0", "9"],
+	["_", "_"],
+	["$", "$"]
+]);
+var C = Lr([
+	["a", "z"],
+	["A", "Z"],
+	["_", "_"]
+]);
+var w = g({
+	name: "sql",
+	states: {
+		main: { rules: [
+			y,
+			b,
+			x,
+			Xr("/*", t, Gr("block_comment")),
+			Xr(["U&'", "u&'"], c, Gr("single_string")),
+			Xr(["U&\"", "u&\""], n, Gr("double_ident")),
+			Xr(["E", "e"], n, Gr("e_prefix_body")),
+			Xr(["N", "n"], n, Gr("n_prefix_body")),
+			Xr(["B", "b"], n, Gr("bx_prefix_body")),
+			Xr(["X", "x"], n, Gr("bx_prefix_body")),
+			Xr("'", c, Gr("single_string")),
+			Xr("\"", n, Gr("double_ident")),
+			Xr("`", n, Gr("backtick_ident")),
+			Xr("[", n, Gr("bracket_ident")),
+			Xr("$$", c, Gr("dollar_string")),
+			Zr("$", Gr("dollar_probe")),
+			Zr("@@", Gr("at_at_probe")),
+			Zr("@", Gr("at_probe")),
+			Xr(v, a),
+			Xr(":", b$1, Gr("colon_var_body")),
+			Xr("?", n, Gr("qmark_body")),
+			Xr(["0x", "0X"], i, Gr("hex_number")),
+			Xr(["0b", "0B"], i, Gr("bin_number")),
+			Xr(["0o", "0O"], i, Gr("oct_number")),
+			Xr(Hr, i, Gr("number")),
+			Xr([
+				"(",
+				")",
+				"{",
+				"}",
+				",",
+				";",
+				"."
+			], o),
+			Xr(C, n, Gr("identifier_body"))
+		] },
+		identifier_body: { rules: [Xr(S, n), ei(qr())] },
+		block_comment: { rules: [
+			Xr("/*", t, Gr("block_comment")),
+			Xr("*/", t, qr()),
+			ei({ token: t })
+		] },
+		single_string: { rules: [
+			Xr("''", Fe),
+			Xr("\\", Fe, Gr("esc_simple")),
+			Xr("'", c, qr()),
+			ei({ token: c })
+		] },
+		pg_escape_string: { rules: [
+			Xr("''", Fe),
+			Xr("\\x", Fe, Gr("esc_hex_d1")),
+			Xr("\\u", Fe, Gr("esc_u4_d1")),
+			Xr("\\U", Fe, Gr("esc_u8_d1")),
+			Xr("\\", Fe, Gr("e_esc_start")),
+			Xr("'", c, qr()),
+			ei({ token: c })
+		] },
+		esc_simple: { rules: [ei({
+			token: Fe,
+			exit: !0
+		})] },
+		e_esc_start: { rules: [Xr(Lr([["0", "7"]]), Fe, Kr("esc_oct_d2")), ei({
+			token: Fe,
+			exit: !0
+		})] },
+		esc_hex_d1: { rules: [Xr(Wr, Fe, Kr("esc_hex_d2")), ei(qr())] },
+		esc_hex_d2: { rules: [Xr(Wr, Fe, qr()), ei(qr())] },
+		esc_u4_d1: { rules: [Xr(Wr, Fe, Kr("esc_u4_d2")), ei(qr())] },
+		esc_u4_d2: { rules: [Xr(Wr, Fe, Kr("esc_u4_d3")), ei(qr())] },
+		esc_u4_d3: { rules: [Xr(Wr, Fe, Kr("esc_u4_d4")), ei(qr())] },
+		esc_u4_d4: { rules: [Xr(Wr, Fe, qr()), ei(qr())] },
+		esc_u8_d1: { rules: [Xr(Wr, Fe, Kr("esc_u8_d2")), ei(qr())] },
+		esc_u8_d2: { rules: [Xr(Wr, Fe, Kr("esc_u8_d3")), ei(qr())] },
+		esc_u8_d3: { rules: [Xr(Wr, Fe, Kr("esc_u8_d4")), ei(qr())] },
+		esc_u8_d4: { rules: [Xr(Wr, Fe, Kr("esc_u8_d5")), ei(qr())] },
+		esc_u8_d5: { rules: [Xr(Wr, Fe, Kr("esc_u8_d6")), ei(qr())] },
+		esc_u8_d6: { rules: [Xr(Wr, Fe, Kr("esc_u8_d7")), ei(qr())] },
+		esc_u8_d7: { rules: [Xr(Wr, Fe, Kr("esc_u8_d8")), ei(qr())] },
+		esc_u8_d8: { rules: [Xr(Wr, Fe, qr()), ei(qr())] },
+		esc_oct_d2: { rules: [Xr(Lr([["0", "7"]]), Fe, Kr("esc_oct_d3")), ei(qr())] },
+		esc_oct_d3: { rules: [Xr(Lr([["0", "7"]]), Fe, qr()), ei(qr())] },
+		e_prefix_body: { rules: [
+			Xr("'", c, Kr("pg_escape_string")),
+			Xr(S, n, Kr("identifier_body")),
+			ei(qr())
+		] },
+		n_prefix_body: { rules: [
+			Xr("'", c, Kr("single_string")),
+			Xr(S, n, Kr("identifier_body")),
+			ei(qr())
+		] },
+		bx_prefix_body: { rules: [
+			Xr("'", "bit", Kr("bit_string")),
+			Xr(S, n, Kr("identifier_body")),
+			ei(qr())
+		] },
+		bit_string: { rules: [Xr("'", "bit", qr()), ei({ token: "bit" })] },
+		dollar_string: { rules: [Xr("$$", c, qr()), ei({ token: c })] },
+		double_ident: { rules: [
+			Xr("\"\"", n),
+			Xr("\"", n, qr()),
+			ei({ token: n })
+		] },
+		backtick_ident: { rules: [
+			Xr("``", n),
+			Xr("`", n, qr()),
+			ei({ token: n })
+		] },
+		bracket_ident: { rules: [
+			Xr("]]", n),
+			Xr("]", n, qr()),
+			ei({ token: n })
+		] },
+		dollar_probe: {
+			mode: "probe",
+			fallback: "dollar_as_operator",
+			rules: [Zr(Hr, Gr("pg_param_start")), Zr([
+				Vr,
+				"_",
+				" ",
+				"	",
+				"\n",
+				"\r",
+				"'",
+				"\"",
+				"`",
+				"[",
+				"]",
+				"{",
+				"}",
+				"(",
+				")",
+				".",
+				",",
+				";",
+				":",
+				"+",
+				"-",
+				"*",
+				"/",
+				"%",
+				"&",
+				"|",
+				"^",
+				"=",
+				"<",
+				">",
+				"~",
+				"!",
+				"?",
+				"@",
+				"#",
+				"$",
+				"\\"
+			], Gr("dollar_as_operator"))]
+		},
+		dollar_as_operator: { rules: [Xr("$", a, qr())] },
+		pg_param_start: { rules: [Xr("$", b$1, Kr("pg_param_body"))] },
+		pg_param_body: { rules: [Xr(Hr, b$1), ei(qr())] },
+		at_at_probe: {
+			mode: "probe",
+			fallback: "at_at_as_operator",
+			rules: [Zr(C, Gr("at_at_variable")), Zr([
+				Hr,
+				" ",
+				"	",
+				"\n",
+				"\r",
+				"'",
+				"\"",
+				"`",
+				"[",
+				"]",
+				"{",
+				"}",
+				"(",
+				")",
+				".",
+				",",
+				";",
+				":",
+				"+",
+				"-",
+				"*",
+				"/",
+				"%",
+				"&",
+				"|",
+				"^",
+				"=",
+				"<",
+				">",
+				"~",
+				"!",
+				"?",
+				"@",
+				"#",
+				"$",
+				"\\"
+			], Gr("at_at_as_operator"))]
+		},
+		at_at_as_operator: { rules: [Xr("@@", a, qr())] },
+		at_at_variable: { rules: [Xr("@@", b$1, Kr("var_name_body"))] },
+		at_probe: {
+			mode: "probe",
+			fallback: "at_as_operator",
+			rules: [Zr(C, Gr("at_variable")), Zr([
+				Hr,
+				" ",
+				"	",
+				"\n",
+				"\r",
+				"'",
+				"\"",
+				"`",
+				"[",
+				"]",
+				"{",
+				"}",
+				"(",
+				")",
+				".",
+				",",
+				";",
+				":",
+				"+",
+				"-",
+				"*",
+				"/",
+				"%",
+				"&",
+				"|",
+				"^",
+				"=",
+				"<",
+				">",
+				"~",
+				"!",
+				"?",
+				"@",
+				"#",
+				"$",
+				"\\"
+			], Gr("at_as_operator"))]
+		},
+		at_as_operator: { rules: [Xr("@", a, qr())] },
+		at_variable: { rules: [Xr("@", b$1, Kr("var_name_body"))] },
+		var_name_body: { rules: [Xr(S, b$1), ei(qr())] },
+		colon_var_body: { rules: [Xr(S, b$1), ei(qr())] },
+		qmark_body: { rules: [Xr(Hr, n), ei(qr())] },
+		number: { rules: [
+			Xr(Hr, i),
+			Xr("_", i),
+			Xr(".", i, Kr("number_decimal")),
+			Xr(["e", "E"], i, Kr("number_exp_sign")),
+			ei(qr())
+		] },
+		number_decimal: { rules: [
+			Xr(Hr, i),
+			Xr("_", i),
+			Xr(["e", "E"], i, Kr("number_exp_sign")),
+			ei(qr())
+		] },
+		number_exp_sign: { rules: [
+			Xr(["+", "-"], i, Kr("number_exp_digits")),
+			Xr(Hr, i, Kr("number_exp_digits")),
+			ei(qr())
+		] },
+		number_exp_digits: { rules: [Xr(Hr, i), ei(qr())] },
+		hex_number: { rules: [Xr([
+			Hr,
+			Lr([["a", "f"], ["A", "F"]]),
+			"_"
+		], i), ei(qr())] },
+		bin_number: { rules: [Xr([Lr([["0", "1"]]), "_"], i), ei(qr())] },
+		oct_number: { rules: [Xr([Lr([["0", "7"]]), "_"], i), ei(qr())] }
+	}
+});
+var T = "type";
+var E = /* @__PURE__ */ new Set([
+	"true",
+	"false",
+	"null",
+	"unknown"
+]);
+var D = new Set(/* @__PURE__ */ "int.integer.smallint.bigint.tinyint.mediumint.int2.int4.int8.decimal.numeric.dec.fixed.real.float.float4.float8.double.precision.char.character.varchar.nvarchar.nchar.text.ntext.clob.nclob.longtext.mediumtext.tinytext.binary.varbinary.blob.longblob.mediumblob.tinyblob.bytea.bit.varbit.image.bool.boolean.date.time.timestamp.datetime.year.interval.timestamptz.timetz.smalldatetime.datetime2.datetimeoffset.json.jsonb.xml.uuid.money.smallmoney.array.enum.record.point.line.lseg.box.path.polygon.circle.inet.cidr.macaddr.macaddr8.tsvector.tsquery.hstore.geometry.geography.rowversion.cursor.hierarchyid.sql_variant.uniqueidentifier.serial.bigserial.smallserial".split("."));
+var O = new Set(/* @__PURE__ */ "select.from.where.group.by.having.order.limit.offset.fetch.first.next.last.union.intersect.except.all.distinct.as.asc.desc.insert.into.values.update.set.delete.returning.upsert.merge.matched.create.alter.drop.truncate.rename.replace.table.view.index.database.schema.trigger.function.procedure.routine.event.sequence.domain.collation.role.user.tablespace.extension.grant.revoke.deny.privileges.to.begin.start.commit.rollback.savepoint.release.work.transaction.isolation.level.serializable.repeatable.read.write.committed.uncommitted.snapshot.join.inner.left.right.full.outer.cross.natural.on.using.lateral.straight_join.apply.pivot.unpivot.tablesample.with.recursive.window.over.partition.row.rows.range.groups.unbounded.preceding.following.current.exclude.ties.others.case.when.then.else.end.if.elseif.elsif.while.loop.for.do.exit.continue.return.returns.declare.cursor.open.close.prior.language.body.try.catch.throw.print.exec.execute.call.and.or.not.xor.in.between.like.ilike.similar.is.isnull.notnull.unique.exists.any.some.collate.div.mod.escape.glob.match.regexp.rlike.overlaps.contains.at.zone.local.default.current_date.current_time.current_timestamp.current_user.session_user.system_user.localtime.localtimestamp.current_role.current_schema.current_catalog.primary.foreign.key.references.check.constraint.generated.always.identity.autoincrement.auto_increment.temporary.temp.global.local.cascade.restrict.deferrable.deferred.immediate.initially.nulls.without.stored.virtual.add.column.change.modify.enable.disable.lock.unlock.tables.show.use.describe.desc.explain.analyze.vacuum.attach.detach.backup.restore.checkpoint.reindex.cluster.dbcc.errlvl.holdlock.nocheck.nonclustered.clustered.opendatasource.openquery.openrowset.openxml.raiserror.reconfigure.revert.rowguidcol.semantickeyphrasetable.try_convert.tsequal.waitfor.recompile.option.fillfactor.go.comment.before.after.instead.each.statement.new.old.of.both.leading.trailing.placing.immutable.stable.volatile.cost.parallel.safe.restricted.unsafe.leakproof.strict.definer.invoker.security.setof.out.inout.variadic.only.rule.materialized.nothing.conflict.excluded.concurrently.verbose.costs.buffers.format.abort.exclusive.share.nowait.skip.locked.filter.within.cast.convert.extract.abort.ignore.fail.abort.replace.perform.raise.notice.warning.exception.found.get.diagnostics.stacked.vacuum.pragma.indexed.without.virtual.materialized.detach.reindex".split("."));
+var k = (e, t) => {
+	let { tokens: n, token_types: r } = t, i = n.length / 3;
+	if (i === 0) return t;
+	let a = r.indexOf("identifier");
+	if (a < 0) return t;
+	let o = (e) => {
+		let t = r.indexOf(e);
+		return t < 0 && (t = r.length, r.push(e)), t;
+	}, s = o("keyword"), c = o("boolean"), l = o(T);
+	for (let t = 0; t < i; t++) {
+		if (n[t * 3] !== a) continue;
+		let r = n[t * 3 + 1], i = n[t * 3 + 2], o = e.charCodeAt(r);
+		if (o === 34 || o === 96 || o === 91) continue;
+		let u = e.slice(r, i).toLowerCase();
+		E.has(u) ? n[t * 3] = c : D.has(u) ? n[t * 3] = l : O.has(u) && (n[t * 3] = s);
+	}
+	return t;
+};
+var A = Ir("identifier", "function", { plain: !0 });
+var j = [Vn(k, [
+	"keyword",
+	"boolean",
+	"type"
+]), Vn(A, ["function"])];
+var M = _(w);
+var N = qn(M, j);
+function P(e) {
+	let t = N(e);
+	return (e, n) => ge(e, t(e), n);
+}
+//#endregion
+export { M as grammar, P as language, w as raw_grammar, j as reclassifiers, N as tokenize };

package/dist/dist-CWYRQLUT.mjs

@@ -0,0 +1,2 @@
+import { n as glob } from "./dist-BvdNTrap.mjs";
+export { glob };