@thomasfosterau/effect-parse 0.0.0 → 0.2.0

package/dist/internal/compiler/sets.js

@@ -1,85 +1,88 @@
-import { compile, compileAny, PredicateRanges } from "../tokens.js";
+import * as Predicate from "effect/Predicate";
+import { PredicateRanges, compile, compileAny } from "../tokens.js";
+import { firstCodePoint } from "../text.js";
+import * as Arr from "effect/Array";
+import * as Order from "effect/Order";
+//#region src/internal/compiler/sets.ts
+/**
+* Token sets for compiled parsers: membership tables for small units, the
+* exact test for the rest, and the code point ranges when they are known.
+*/
 /** Size of the membership table: every byte, and the Latin-1 code points. */
-export const TableSize = 256;
-const isRange = (u) => typeof u === "object" && u !== null && u._tag === "TokenRange";
-const toCode = (u) => typeof u === "number" ? u : u.codePointAt(0);
+const TableSize = 256;
+const isRange = (u) => Predicate.isObjectOrArray(u) && u._tag === "TokenRange";
+const toCode = (u) => Predicate.isNumber(u) ? u : firstCodePoint(u);
 /** The code point ranges of a token set, or `undefined` if it has an unknown predicate. */
-export const rangesOf = (set) => {
-    const out = [];
-    const add = (u) => {
-        if (typeof u === "string") {
-            for (const c of u) {
-                const cp = c.codePointAt(0);
-                out.push([cp, cp]);
-            }
-            return true;
-        }
-        if (typeof u === "number") {
-            out.push([u, u]);
-            return true;
-        }
-        if (u instanceof Uint8Array) {
-            for (const b of u)
-                out.push([b, b]);
-            return true;
-        }
-        if (isRange(u)) {
-            out.push([toCode(u.from), toCode(u.to)]);
-            return true;
-        }
-        if (typeof u === "function") {
-            const r = u[PredicateRanges];
-            if (r === undefined)
-                return false;
-            for (const [a, b] of r)
-                out.push([a, b]);
-            return true;
-        }
-        if (Array.isArray(u))
-            return u.every(add);
-        return false;
-    };
-    if (!add(set))
-        return undefined;
-    out.sort((a, b) => a[0] - b[0]);
-    const merged = [];
-    for (const [a, b] of out) {
-        if (b < a)
-            continue;
-        const last = merged[merged.length - 1];
-        if (last !== undefined && a <= last[1] + 1)
-            last[1] = Math.max(last[1], b);
-        else
-            merged.push([a, b]);
-    }
-    return merged;
+const rangesOf = (set) => {
+	const out = [];
+	const add = (u) => {
+		if (Predicate.isString(u)) {
+			for (const c of u) {
+				const cp = firstCodePoint(c);
+				out.push([cp, cp]);
+			}
+			return true;
+		}
+		if (Predicate.isNumber(u)) {
+			out.push([u, u]);
+			return true;
+		}
+		if (u instanceof Uint8Array) {
+			for (const b of u) out.push([b, b]);
+			return true;
+		}
+		if (isRange(u)) {
+			out.push([toCode(u.from), toCode(u.to)]);
+			return true;
+		}
+		if (Predicate.isFunction(u)) {
+			const r = u[PredicateRanges];
+			if (r === void 0) return false;
+			for (const [a, b] of r) out.push([a, b]);
+			return true;
+		}
+		if (Array.isArray(u)) return u.every(add);
+		return false;
+	};
+	if (!add(set)) return void 0;
+	const merged = [];
+	for (const [a, b] of Arr.sort(out, Order.mapInput(Order.Number, (range) => range[0]))) {
+		if (b < a) continue;
+		const last = merged[merged.length - 1];
+		if (last !== void 0 && a <= last[1] + 1) last[1] = Math.max(last[1], b);
+		else merged.push([a, b]);
+	}
+	return merged;
 };
 const makeSet = (test, set) => {
-    // The table calls the test once per small code: token-set predicates are
-    // assumed to be pure (see the design notes).
-    const table = new Uint8Array(TableSize);
-    for (let c = 0; c < TableSize; c++)
-        table[c] = test(c) ? 1 : 0;
-    return { test, table, ranges: rangesOf(set) };
+	const table = /* @__PURE__ */ new Uint8Array(256);
+	for (let c = 0; c < 256; c++) table[c] = test(c) ? 1 : 0;
+	return {
+		test,
+		table,
+		ranges: rangesOf(set)
+	};
 };
 /**
- * The set as a `Token` parser sees it: string predicates receive strings on
- * string input, everything receives numbers on byte input.
- */
-export const tokenSet = (set, kind) => {
-    const m = compileAny(set);
-    return makeSet(kind === 0 ? m.forString.code : m.forCode.code, set);
+* The set as a `Token` parser sees it: string predicates receive strings on
+* string input, everything receives numbers on byte input.
+*/
+const tokenSet = (set, kind) => {
+	const m = compileAny(set);
+	return makeSet(kind === 0 ? m.forString.code : m.forCode.code, set);
 };
 /** The set as a `Text` parser sees it: code points, for any encoding. */
-export const textSet = (set) => makeSet(compile(set, "string").code, set);
+const textSet = (set) => makeSet(compile(set, "string").code, set);
 /** Whether some accepted code point is at least `limit` (true when unknown). */
-export const reachesAbove = (s, limit) => s.ranges === undefined || s.ranges.some(([, b]) => b >= limit);
+const reachesAbove = (s, limit) => s.ranges === void 0 || s.ranges.some(([, b]) => b >= limit);
 /** The input kind a `Text` encoding reads: 0 for strings, 1 for bytes. */
-export const kindOfEncoding = (enc) => {
-    let k = kinds.get(enc);
-    if (k === undefined)
-        kinds.set(enc, k = typeof enc.encode("") === "string" ? 0 : 1);
-    return k;
+const kindOfEncoding = (enc) => {
+	let k = kinds.get(enc);
+	if (k === void 0) kinds.set(enc, k = Predicate.isString(enc.encode("")) ? 0 : 1);
+	return k;
 };
-const kinds = new WeakMap();
+const kinds = /*#__PURE__*/ new WeakMap();
+//#endregion
+export { TableSize, kindOfEncoding, reachesAbove, textSet, tokenSet };
+
 //# sourceMappingURL=sets.js.map

package/dist/internal/compiler/sets.js.map

@@ -1 +1 @@
-{"version":3,"file":"sets.js","sourceRoot":"","sources":["../../../src/internal/compiler/sets.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"sets.js","names":[],"sources":["../../../src/internal/compiler/sets.ts"],"sourcesContent":["/**\n * Token sets for compiled parsers: membership tables for small units, the\n * exact test for the rest, and the code point ranges when they are known.\n */\nimport * as Arr from \"effect/Array\"\nimport * as Order from \"effect/Order\"\nimport * as Predicate from \"effect/Predicate\"\nimport type { Encoding } from \"../../Encoding.js\"\nimport { firstCodePoint } from \"../text.js\"\nimport { compile, compileAny, PredicateRanges } from \"../tokens.js\"\n\n/** Size of the membership table: every byte, and the Latin-1 code points. */\nexport const TableSize = 256\n\nexport interface CharSet {\n  /** Tests a code point (or byte, for `Token` on bytes). */\n  readonly test: (code: number) => boolean\n  /** `table[c] === 1` iff `test(c)`, for `c < TableSize`. */\n  readonly table: Uint8Array\n  /** Sorted inclusive ranges of accepted code points, when known. */\n  readonly ranges: ReadonlyArray<readonly [number, number]> | undefined\n}\n\nconst isRange = (u: unknown): u is { readonly from: string | number; readonly to: string | number } =>\n  Predicate.isObjectOrArray(u) && (u as any)._tag === \"TokenRange\"\n\nconst toCode = (u: string | number): number => (Predicate.isNumber(u) ? u : firstCodePoint(u))\n\n/** The code point ranges of a token set, or `undefined` if it has an unknown predicate. */\nconst rangesOf = (set: unknown): Array<[number, number]> | undefined => {\n  const out: Array<[number, number]> = []\n  const add = (u: unknown): boolean => {\n    if (Predicate.isString(u)) {\n      for (const c of u) {\n        const cp = firstCodePoint(c)\n        out.push([cp, cp])\n      }\n      return true\n    }\n    if (Predicate.isNumber(u)) {\n      out.push([u, u])\n      return true\n    }\n    if (u instanceof Uint8Array) {\n      for (const b of u) out.push([b, b])\n      return true\n    }\n    if (isRange(u)) {\n      out.push([toCode(u.from), toCode(u.to)])\n      return true\n    }\n    if (Predicate.isFunction(u)) {\n      const r = (u as any)[PredicateRanges] as ReadonlyArray<readonly [number, number]> | undefined\n      if (r === undefined) return false\n      for (const [a, b] of r) out.push([a, b])\n      return true\n    }\n    if (Array.isArray(u)) return u.every(add)\n    return false\n  }\n  if (!add(set)) return undefined\n  const merged: Array<[number, number]> = []\n  for (const [a, b] of Arr.sort(\n    out,\n    Order.mapInput(Order.Number, (range: readonly [number, number]) => range[0])\n  )) {\n    if (b < a) continue\n    const last = merged[merged.length - 1]\n    if (last !== undefined && a <= last[1] + 1) last[1] = Math.max(last[1], b)\n    else merged.push([a, b])\n  }\n  return merged\n}\n\nconst makeSet = (test: (code: number) => boolean, set: unknown): CharSet => {\n  // The table calls the test once per small code: token-set predicates are\n  // assumed to be pure (see the design notes).\n  const table = new Uint8Array(TableSize)\n  for (let c = 0; c < TableSize; c++) table[c] = test(c) ? 1 : 0\n  return { test, table, ranges: rangesOf(set) }\n}\n\n/**\n * The set as a `Token` parser sees it: string predicates receive strings on\n * string input, everything receives numbers on byte input.\n */\nexport const tokenSet = (set: unknown, kind: 0 | 1): CharSet => {\n  const m = compileAny(set)\n  return makeSet(kind === 0 ? m.forString.code : m.forCode.code, set)\n}\n\n/** The set as a `Text` parser sees it: code points, for any encoding. */\nexport const textSet = (set: unknown): CharSet => makeSet(compile(set, \"string\").code, set)\n\n/** Whether some accepted code point is at least `limit` (true when unknown). */\nexport const reachesAbove = (s: CharSet, limit: number): boolean =>\n  s.ranges === undefined || s.ranges.some(([, b]) => b >= limit)\n\n/** The input kind a `Text` encoding reads: 0 for strings, 1 for bytes. */\nexport const kindOfEncoding = (enc: Encoding<any>): 0 | 1 => {\n  let k = kinds.get(enc)\n  if (k === undefined) kinds.set(enc, (k = Predicate.isString(enc.encode(\"\")) ? 0 : 1))\n  return k\n}\n\nconst kinds = /*#__PURE__*/ new WeakMap<Encoding<any>, 0 | 1>()\n"],"mappings":";;;;;;;;;;;AAYA,MAAa,YAAY;AAWzB,MAAM,WAAW,MACf,UAAU,gBAAgB,CAAC,KAAM,EAAU,SAAS;AAEtD,MAAM,UAAU,MAAgC,UAAU,SAAS,CAAC,IAAI,IAAI,eAAe,CAAC;;AAG5F,MAAM,YAAY,QAAsD;CACtE,MAAM,MAA+B,CAAC;CACtC,MAAM,OAAO,MAAwB;EACnC,IAAI,UAAU,SAAS,CAAC,GAAG;GACzB,KAAK,MAAM,KAAK,GAAG;IACjB,MAAM,KAAK,eAAe,CAAC;IAC3B,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;GACnB;GACA,OAAO;EACT;EACA,IAAI,UAAU,SAAS,CAAC,GAAG;GACzB,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC;GACf,OAAO;EACT;EACA,IAAI,aAAa,YAAY;GAC3B,KAAK,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC;GAClC,OAAO;EACT;EACA,IAAI,QAAQ,CAAC,GAAG;GACd,IAAI,KAAK,CAAC,OAAO,EAAE,IAAI,GAAG,OAAO,EAAE,EAAE,CAAC,CAAC;GACvC,OAAO;EACT;EACA,IAAI,UAAU,WAAW,CAAC,GAAG;GAC3B,MAAM,IAAK,EAAU;GACrB,IAAI,MAAM,KAAA,GAAW,OAAO;GAC5B,KAAK,MAAM,CAAC,GAAG,MAAM,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC;GACvC,OAAO;EACT;EACA,IAAI,MAAM,QAAQ,CAAC,GAAG,OAAO,EAAE,MAAM,GAAG;EACxC,OAAO;CACT;CACA,IAAI,CAAC,IAAI,GAAG,GAAG,OAAO,KAAA;CACtB,MAAM,SAAkC,CAAC;CACzC,KAAK,MAAM,CAAC,GAAG,MAAM,IAAI,KACvB,KACA,MAAM,SAAS,MAAM,SAAS,UAAqC,MAAM,EAAE,CAC7E,GAAG;EACD,IAAI,IAAI,GAAG;EACX,MAAM,OAAO,OAAO,OAAO,SAAS;EACpC,IAAI,SAAS,KAAA,KAAa,KAAK,KAAK,KAAK,GAAG,KAAK,KAAK,KAAK,IAAI,KAAK,IAAI,CAAC;OACpE,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC;CACzB;CACA,OAAO;AACT;AAEA,MAAM,WAAW,MAAiC,QAA0B;CAG1E,MAAM,wBAAQ,IAAI,WAAA,GAAoB;CACtC,KAAK,IAAI,IAAI,GAAG,IAAA,KAAe,KAAK,MAAM,KAAK,KAAK,CAAC,IAAI,IAAI;CAC7D,OAAO;EAAE;EAAM;EAAO,QAAQ,SAAS,GAAG;CAAE;AAC9C;;;;;AAMA,MAAa,YAAY,KAAc,SAAyB;CAC9D,MAAM,IAAI,WAAW,GAAG;CACxB,OAAO,QAAQ,SAAS,IAAI,EAAE,UAAU,OAAO,EAAE,QAAQ,MAAM,GAAG;AACpE;;AAGA,MAAa,WAAW,QAA0B,QAAQ,QAAQ,KAAK,QAAQ,CAAC,CAAC,MAAM,GAAG;;AAG1F,MAAa,gBAAgB,GAAY,UACvC,EAAE,WAAW,KAAA,KAAa,EAAE,OAAO,MAAM,GAAG,OAAO,KAAK,KAAK;;AAG/D,MAAa,kBAAkB,QAA8B;CAC3D,IAAI,IAAI,MAAM,IAAI,GAAG;CACrB,IAAI,MAAM,KAAA,GAAW,MAAM,IAAI,KAAM,IAAI,UAAU,SAAS,IAAI,OAAO,EAAE,CAAC,IAAI,IAAI,CAAE;CACpF,OAAO;AACT;AAEA,MAAM,sBAAsB,IAAI,QAA8B"}

package/dist/internal/entries.d.ts

@@ -1,12 +1,11 @@
+//#region src/internal/entries.d.ts
 /**
  * Building objects as `Object.fromEntries` does, without its array of
  * `[key, value]` pairs: the compilers use these when a parser maps a
  * repetition of pairs with `Object.fromEntries` (see `Parser.fromEntries`).
  */
 /** The built-in `Object.fromEntries`, which compiled parsers recognize. */
-export declare const fromEntries: <K extends PropertyKey, V>(entries: Iterable<readonly [K, V]>) => {
-    [P in K]: V;
-};
+export declare const fromEntries: <K extends PropertyKey, V>(entries: Iterable<readonly [K, V]>) => { [P in K]: V; };
 /**
  * Whether `o[key] = value` on a new plain object creates the same property
  * as `Object.fromEntries` (a writable, enumerable, configurable data
@@ -24,4 +23,5 @@ export declare const isPlainKey: (key: unknown) => key is string;
 export declare const addEntry: (o: object, deferred: Array<unknown> | undefined, key: unknown, value: unknown) => Array<unknown> | undefined;
 /** Adds the deferred entries of {@link addEntry} to `o`, in order. */
 export declare const flushEntries: (o: object, deferred: ReadonlyArray<unknown>) => void;
+//#endregion
 //# sourceMappingURL=entries.d.ts.map

package/dist/internal/entries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entries.d.ts","sourceRoot":"","sources":["../../src/internal/entries.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,2EAA2E;AAC3E,eAAO,MAAM,WAAW,EAAE,CAAC,CAAC,SAAS,WAAW,EAAE,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK;KAAG,CAAC,IAAI,CAAC,GAAG,CAAC;CAC9E,CAAA;AAK3B;;;;;GAKG;AACH,eAAO,MAAM,UAAU,QAAS,OAAO,KAAG,GAAG,IAAI,MAAuE,CAAA;AAMxH;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,MAChB,MAAM,YACC,KAAK,CAAC,OAAO,CAAC,GAAG,SAAS,OAC/B,OAAO,SACL,OAAO,KACb,KAAK,CAAC,OAAO,CAAC,GAAG,SAQnB,CAAA;AAED,sEAAsE;AACtE,eAAO,MAAM,YAAY,MAAO,MAAM,YAAY,aAAa,CAAC,OAAO,CAAC,KAAG,IAE1E,CAAA"}
+{"version":3,"file":"entries.d.ts","names":[],"sources":["../../src/internal/entries.ts"],"mappings":";;;;;;;qBASa,cAAc,UAAU,aAAa,GAAG,SAAS,mBAAmB,GAAG,WAAW,KAAK,IAAI;;;;;;;qBAY3F,aAAc,iBAAe;;;;;;;;qBAa7B,WACX,WACA,UAAU,4BACV,cACA,mBACC;;qBAWU,eAAgB,WAAW,UAAU"}

package/dist/internal/entries.js

@@ -1,42 +1,50 @@
+import * as Predicate from "effect/Predicate";
+//#region src/internal/entries.ts
 /**
- * Building objects as `Object.fromEntries` does, without its array of
- * `[key, value]` pairs: the compilers use these when a parser maps a
- * repetition of pairs with `Object.fromEntries` (see `Parser.fromEntries`).
- */
+* Building objects as `Object.fromEntries` does, without its array of
+* `[key, value]` pairs: the compilers use these when a parser maps a
+* repetition of pairs with `Object.fromEntries` (see `Parser.fromEntries`).
+*/
 /** The built-in `Object.fromEntries`, which compiled parsers recognize. */
-export const fromEntries = Object.fromEntries;
+const fromEntries = Object.fromEntries;
 const objectPrototype = Object.prototype;
 const hasOwn = objectPrototype.hasOwnProperty;
 /**
- * Whether `o[key] = value` on a new plain object creates the same property
- * as `Object.fromEntries` (a writable, enumerable, configurable data
- * property): `key` is a string that `Object.prototype` has no property for,
- * so there is no setter (`__proto__`) or read-only property to run into.
- */
-export const isPlainKey = (key) => typeof key === "string" && !hasOwn.call(objectPrototype, key);
+* Whether `o[key] = value` on a new plain object creates the same property
+* as `Object.fromEntries` (a writable, enumerable, configurable data
+* property): `key` is a string that `Object.prototype` has no property for,
+* so there is no setter (`__proto__`) or read-only property to run into.
+*/
+const isPlainKey = (key) => Predicate.isString(key) && !hasOwn.call(objectPrototype, key);
 const define = (o, key, value) => {
-    Object.defineProperty(o, key, { value, writable: true, enumerable: true, configurable: true });
+	Object.defineProperty(o, key, {
+		value,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
 };
 /**
- * Adds an entry whose key is not plain to `o`, given the entries already
- * deferred. Keys that are objects may run code when converted to property
- * keys, which `Object.fromEntries` only does once every entry is parsed:
- * from the first such key on, entries are deferred to {@link flushEntries}.
- * Returns the deferred entries, if any.
- */
-export const addEntry = (o, deferred, key, value) => {
-    if (deferred === undefined && (typeof key !== "object" || key === null) && typeof key !== "function") {
-        define(o, key, value);
-        return undefined;
-    }
-    if (deferred === undefined)
-        deferred = [];
-    deferred.push(key, value);
-    return deferred;
+* Adds an entry whose key is not plain to `o`, given the entries already
+* deferred. Keys that are objects may run code when converted to property
+* keys, which `Object.fromEntries` only does once every entry is parsed:
+* from the first such key on, entries are deferred to {@link flushEntries}.
+* Returns the deferred entries, if any.
+*/
+const addEntry = (o, deferred, key, value) => {
+	if (deferred === void 0 && !Predicate.isObjectOrArray(key) && !Predicate.isFunction(key)) {
+		define(o, key, value);
+		return;
+	}
+	if (deferred === void 0) deferred = [];
+	deferred.push(key, value);
+	return deferred;
 };
 /** Adds the deferred entries of {@link addEntry} to `o`, in order. */
-export const flushEntries = (o, deferred) => {
-    for (let i = 0; i < deferred.length; i += 2)
-        define(o, deferred[i], deferred[i + 1]);
+const flushEntries = (o, deferred) => {
+	for (let i = 0; i < deferred.length; i += 2) define(o, deferred[i], deferred[i + 1]);
 };
+//#endregion
+export { addEntry, flushEntries, fromEntries, isPlainKey };
+
 //# sourceMappingURL=entries.js.map

package/dist/internal/entries.js.map

@@ -1 +1 @@
-{"version":3,"file":"entries.js","sourceRoot":"","sources":["../../src/internal/entries.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,2EAA2E;AAC3E,MAAM,CAAC,MAAM,WAAW,GACtB,MAAM,CAAC,WAAkB,CAAA;AAE3B,MAAM,eAAe,GAAG,MAAM,CAAC,SAAS,CAAA;AACxC,MAAM,MAAM,GAAG,eAAe,CAAC,cAAc,CAAA;AAE7C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,GAAY,EAAiB,EAAE,CAAC,OAAO,GAAG,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,eAAe,EAAE,GAAG,CAAC,CAAA;AAExH,MAAM,MAAM,GAAG,CAAC,CAAS,EAAE,GAAY,EAAE,KAAc,EAAQ,EAAE;IAC/D,MAAM,CAAC,cAAc,CAAC,CAAC,EAAE,GAAkB,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAA;AAC/G,CAAC,CAAA;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CACtB,CAAS,EACT,QAAoC,EACpC,GAAY,EACZ,KAAc,EACc,EAAE;IAC9B,IAAI,QAAQ,KAAK,SAAS,IAAI,CAAC,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI,CAAC,IAAI,OAAO,GAAG,KAAK,UAAU,EAAE,CAAC;QACrG,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAA;QACrB,OAAO,SAAS,CAAA;IAClB,CAAC;IACD,IAAI,QAAQ,KAAK,SAAS;QAAE,QAAQ,GAAG,EAAE,CAAA;IACzC,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;IACzB,OAAO,QAAQ,CAAA;AACjB,CAAC,CAAA;AAED,sEAAsE;AACtE,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAS,EAAE,QAAgC,EAAQ,EAAE;IAChF,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC;QAAE,MAAM,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;AACtF,CAAC,CAAA"}
+{"version":3,"file":"entries.js","names":[],"sources":["../../src/internal/entries.ts"],"sourcesContent":["/**\n * Building objects as `Object.fromEntries` does, without its array of\n * `[key, value]` pairs: the compilers use these when a parser maps a\n * repetition of pairs with `Object.fromEntries` (see `Parser.fromEntries`).\n */\n\nimport * as Predicate from \"effect/Predicate\"\n\n/** The built-in `Object.fromEntries`, which compiled parsers recognize. */\nexport const fromEntries: <K extends PropertyKey, V>(entries: Iterable<readonly [K, V]>) => { [P in K]: V } =\n  Object.fromEntries as any\n\nconst objectPrototype = Object.prototype\nconst hasOwn = objectPrototype.hasOwnProperty\n\n/**\n * Whether `o[key] = value` on a new plain object creates the same property\n * as `Object.fromEntries` (a writable, enumerable, configurable data\n * property): `key` is a string that `Object.prototype` has no property for,\n * so there is no setter (`__proto__`) or read-only property to run into.\n */\nexport const isPlainKey = (key: unknown): key is string => Predicate.isString(key) && !hasOwn.call(objectPrototype, key)\n\nconst define = (o: object, key: unknown, value: unknown): void => {\n  Object.defineProperty(o, key as PropertyKey, { value, writable: true, enumerable: true, configurable: true })\n}\n\n/**\n * Adds an entry whose key is not plain to `o`, given the entries already\n * deferred. Keys that are objects may run code when converted to property\n * keys, which `Object.fromEntries` only does once every entry is parsed:\n * from the first such key on, entries are deferred to {@link flushEntries}.\n * Returns the deferred entries, if any.\n */\nexport const addEntry = (\n  o: object,\n  deferred: Array<unknown> | undefined,\n  key: unknown,\n  value: unknown\n): Array<unknown> | undefined => {\n  if (deferred === undefined && !Predicate.isObjectOrArray(key) && !Predicate.isFunction(key)) {\n    define(o, key, value)\n    return undefined\n  }\n  if (deferred === undefined) deferred = []\n  deferred.push(key, value)\n  return deferred\n}\n\n/** Adds the deferred entries of {@link addEntry} to `o`, in order. */\nexport const flushEntries = (o: object, deferred: ReadonlyArray<unknown>): void => {\n  for (let i = 0; i < deferred.length; i += 2) define(o, deferred[i], deferred[i + 1])\n}\n"],"mappings":";;;;;;;;AASA,MAAa,cACX,OAAO;AAET,MAAM,kBAAkB,OAAO;AAC/B,MAAM,SAAS,gBAAgB;;;;;;;AAQ/B,MAAa,cAAc,QAAgC,UAAU,SAAS,GAAG,KAAK,CAAC,OAAO,KAAK,iBAAiB,GAAG;AAEvH,MAAM,UAAU,GAAW,KAAc,UAAyB;CAChE,OAAO,eAAe,GAAG,KAAoB;EAAE;EAAO,UAAU;EAAM,YAAY;EAAM,cAAc;CAAK,CAAC;AAC9G;;;;;;;;AASA,MAAa,YACX,GACA,UACA,KACA,UAC+B;CAC/B,IAAI,aAAa,KAAA,KAAa,CAAC,UAAU,gBAAgB,GAAG,KAAK,CAAC,UAAU,WAAW,GAAG,GAAG;EAC3F,OAAO,GAAG,KAAK,KAAK;EACpB;CACF;CACA,IAAI,aAAa,KAAA,GAAW,WAAW,CAAC;CACxC,SAAS,KAAK,KAAK,KAAK;CACxB,OAAO;AACT;;AAGA,MAAa,gBAAgB,GAAW,aAA2C;CACjF,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK,GAAG,OAAO,GAAG,SAAS,IAAI,SAAS,IAAI,EAAE;AACrF"}