@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/Packet-CA76wVX3.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Packet-CA76wVX3.mjs","names":[],"sources":["../src/xmp/Packet.ts"],"sourcesContent":["/**\n * XMP packets (ISO 16684-1 §7.3): finding `<?xpacket begin=… ?>` …\n * `<?xpacket end=\"w\"?>` in arbitrary bytes, and wrapping serialized XMP in\n * a packet with the whitespace padding that lets a writer update it in\n * place.\n *\n * Packets are found in UTF-8, UTF-16 and UTF-32 (either byte order), the\n * encodings ISO 16684-1 §7.3.2 lets a packet use and a byte scanner can\n * recognise without parsing the host file.\n *\n * @since 0.1.0\n */\nimport * as Arr from 'effect/Array';\nimport * as Option from 'effect/Option';\nimport * as Order from 'effect/Order';\n\n/**\n * The `id` attribute every packet header carries.\n *\n * @since 0.1.0\n * @category constants\n */\nexport const PACKET_ID = 'W5M0MpCehiHzreSzNTczkc9d';\n\n/**\n * The padding a writable packet gets by default: 2 KiB, as the XMP\n * specification recommends.\n *\n * @since 0.1.0\n * @category constants\n */\nexport const DEFAULT_PADDING = 2048;\n\n/**\n * The text encoding of a packet.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Encoding = 'utf-8' | 'utf-16be' | 'utf-16le' | 'utf-32be' | 'utf-32le';\n\n/**\n * A packet found in a byte sequence.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Packet {\n  /** The byte offset of `<?xpacket begin`. */\n  readonly offset: number;\n  /** The byte length, through the end of the `<?xpacket end …?>` trailer. */\n  readonly length: number;\n  readonly encoding: Encoding;\n  /** Whether the trailer is `end=\"w\"` (the packet may be updated in place). */\n  readonly writable: boolean;\n  /** The decoded packet, header to trailer. */\n  readonly text: string;\n}\n\n/**\n * The parts of a packet's text.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Unwrapped {\n  /** The serialized XMP between the header and the padding. */\n  readonly xml: string;\n  /** The number of whitespace characters of padding before the trailer. */\n  readonly padding: number;\n  readonly writable: boolean;\n}\n\nconst HEADER = '<?xpacket begin=';\nconst TRAILER = '<?xpacket end=';\nconst PI_END = '?>';\n\nconst ENCODINGS: ReadonlyArray<Encoding> = [\n  'utf-8',\n  'utf-16be',\n  'utf-16le',\n  'utf-32be',\n  'utf-32le',\n];\n\nconst WIDTHS: Readonly<Record<Encoding, number>> = {\n  'utf-8': 1,\n  'utf-16be': 2,\n  'utf-16le': 2,\n  'utf-32be': 4,\n  'utf-32le': 4,\n};\n\nconst isLittleEndian = (encoding: Encoding): boolean => encoding.endsWith('le');\n\n/** One ASCII code unit in an encoding: the code, zero-padded to the unit's width. */\nconst asciiUnit = (code: number, encoding: Encoding): ReadonlyArray<number> => {\n  // `Arr.replicate` never returns an empty array, and UTF-8 needs none.\n  const padding = Array.from({ length: WIDTHS[encoding] - 1 }, () => 0);\n  return isLittleEndian(encoding) ? [code, ...padding] : [...padding, code];\n};\n\nconst encodeAscii = (text: string, encoding: Encoding): Uint8Array =>\n  Uint8Array.from(Arr.flatMap(Arr.fromIterable(text), (c) => asciiUnit(c.charCodeAt(0), encoding)));\n\n/**\n * Decodes UTF-32, which the WHATWG `TextDecoder` does not support. A code\n * point outside Unicode, or a surrogate, decodes to U+FFFD as `TextDecoder`\n * would.\n */\nconst decodeUtf32 = (bytes: Uint8Array, littleEndian: boolean): string => {\n  const data = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n  const units = Math.floor(bytes.length / 4);\n  return Array.from({ length: units }, (_, i) => {\n    const code = data.getUint32(i * 4, littleEndian);\n    return code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff)\n      ? '\\uFFFD'\n      : String.fromCodePoint(code);\n  }).join('');\n};\n\nconst decode = (bytes: Uint8Array, encoding: Encoding): string =>\n  WIDTHS[encoding] === 4\n    ? decodeUtf32(bytes, isLittleEndian(encoding))\n    : new TextDecoder(encoding).decode(bytes);\n\n// windows-1252 decodes every byte to exactly one UTF-16 code unit, so a\n// string search over the decoded bytes finds byte offsets natively.\nconst bytesToString = (bytes: Uint8Array): string => new TextDecoder('windows-1252').decode(bytes);\n\nconst marker = (text: string, encoding: Encoding): string =>\n  bytesToString(encodeAscii(text, encoding));\n\nconst indexIn = (haystack: string, needle: string, from: number): Option.Option<number> => {\n  const i = haystack.indexOf(needle, from);\n  return i < 0 ? Option.none() : Option.some(i);\n};\n\nconst isWritable = (text: string, trailer: number): boolean =>\n  text.charAt(trailer + TRAILER.length + 1) === 'w';\n\nconst findIn = (bytes: Uint8Array, haystack: string, from: number): Option.Option<Packet> => {\n  const starts = Arr.getSomes(\n    Arr.map(ENCODINGS, (encoding) =>\n      Option.map(indexIn(haystack, marker(HEADER, encoding), from), (offset) => ({\n        offset,\n        encoding,\n      })),\n    ),\n  );\n  const first = Arr.head(\n    Arr.sort(\n      starts,\n      Order.mapInput(Order.Number, (s: { readonly offset: number }) => s.offset),\n    ),\n  );\n  return Option.flatMap(first, ({ offset, encoding }) => {\n    const width = WIDTHS[encoding];\n    const end = Option.flatMap(\n      indexIn(haystack, marker(TRAILER, encoding), offset + HEADER.length * width),\n      (trailer) =>\n        Option.map(\n          indexIn(haystack, marker(PI_END, encoding), trailer + TRAILER.length * width),\n          (close) => close + PI_END.length * width,\n        ),\n    );\n    // A header with no trailer after it is not a packet, and neither is any\n    // later header.\n    return Option.map(end, (close): Packet => {\n      const text = decode(bytes.subarray(offset, close), encoding);\n      return {\n        offset,\n        length: close - offset,\n        encoding,\n        writable: isWritable(text, text.lastIndexOf(TRAILER)),\n        text,\n      };\n    });\n  });\n};\n\n/**\n * Finds the first packet at or after `fromIndex` in a byte sequence: a file\n * of any format, scanned without parsing it (ISO 16684-1 §7.3.2's packet\n * scanning).\n *\n * @since 0.1.0\n * @category scanning\n */\nexport const find = (bytes: Uint8Array, fromIndex: number = 0): Option.Option<Packet> =>\n  findIn(bytes, bytesToString(bytes), fromIndex);\n\n/**\n * Finds every packet in a byte sequence, in order.\n *\n * @since 0.1.0\n * @category scanning\n */\nexport const findAll = (bytes: Uint8Array): ReadonlyArray<Packet> => {\n  const haystack = bytesToString(bytes);\n  return Arr.unfold(0, (from) =>\n    Option.map(findIn(bytes, haystack, from), (p) => [p, p.offset + p.length] as const),\n  );\n};\n\n/**\n * Splits a packet's text into the serialized XMP, the padding and the\n * writability of its trailer. Returns `None` when the text is not a packet.\n *\n * @since 0.1.0\n * @category parsing\n */\nexport const unwrap = (text: string): Option.Option<Unwrapped> =>\n  Option.flatMap(indexIn(text, HEADER, 0), (start) =>\n    Option.flatMap(indexIn(text, PI_END, start), (headerEnd) => {\n      const trailer = text.lastIndexOf(TRAILER);\n      if (trailer < headerEnd) return Option.none();\n      const content = text.slice(headerEnd + PI_END.length, trailer).replace(/^\\r?\\n/, '');\n      const xml = content.trimEnd();\n      return Option.some({\n        xml,\n        padding: content.length - xml.length,\n        writable: isWritable(text, trailer),\n      });\n    }),\n  );\n\n/**\n * Options for wrapping serialized XMP in a packet.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface WrapOptions {\n  /**\n   * Bytes of whitespace padding before the trailer. Defaults to\n   * `DEFAULT_PADDING` for a writable packet and 0 for a read-only one.\n   */\n  readonly padding?: number | undefined;\n  /** Whether the trailer is `end=\"w\"` rather than `end=\"r\"`. Defaults to `true`. */\n  readonly writable?: boolean | undefined;\n}\n\nconst header = `<?xpacket begin=\"\" id=\"${PACKET_ID}\"?>\\n`;\nconst trailerOf = (writable: boolean) => `<?xpacket end=\"${writable ? 'w' : 'r'}\"?>`;\n\n/**\n * Whitespace padding of exactly `bytes` bytes: lines of 99 spaces and a\n * newline, as XMP writers lay it out.\n *\n * @since 0.1.0\n * @category serializing\n */\nexport const padding = (bytes: number): string => {\n  const lines = Math.floor(bytes / 100);\n  return `${`${' '.repeat(99)}\\n`.repeat(lines)}${' '.repeat(bytes - lines * 100)}`;\n};\n\nconst body = (xml: string) => (xml.endsWith('\\n') ? xml : `${xml}\\n`);\n\n/**\n * Wraps serialized XMP (an `<x:xmpmeta>` element) in a UTF-8 packet.\n *\n * @since 0.1.0\n * @category serializing\n */\nexport const wrap = (xml: string, options?: WrapOptions): string => {\n  const writable = options?.writable ?? true;\n  const pad = options?.padding ?? (writable ? DEFAULT_PADDING : 0);\n  return `${header}${body(xml)}${padding(pad)}${trailerOf(writable)}`;\n};\n\n/**\n * The UTF-8 byte length of a string.\n *\n * @since 0.1.0\n * @category serializing\n */\nexport const byteLength = (text: string): number => new TextEncoder().encode(text).length;\n\n/**\n * Wraps serialized XMP in a UTF-8 packet of exactly `size` bytes, padding the\n * difference: how an XMP packet is updated in place in a file. Returns\n * `None` when the XMP does not fit.\n *\n * @since 0.1.0\n * @category serializing\n */\nexport const wrapToSize = (\n  xml: string,\n  size: number,\n  options?: { readonly writable?: boolean | undefined },\n): Option.Option<string> => {\n  const writable = options?.writable ?? true;\n  const fixed = byteLength(`${header}${body(xml)}${trailerOf(writable)}`);\n  return fixed > size ? Option.none() : Option.some(wrap(xml, { writable, padding: size - fixed }));\n};\n"],"mappings":"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"}

package/dist/Packet-Cy5g6XuW.d.mts

@@ -0,0 +1,130 @@
+import * as Option from "effect/Option";
+declare namespace Packet_d_exports {
+  export { DEFAULT_PADDING, Encoding, PACKET_ID, Packet, Unwrapped, WrapOptions, byteLength, find, findAll, padding, unwrap, wrap, wrapToSize };
+}
+/**
+ * The `id` attribute every packet header carries.
+ *
+ * @since 0.1.0
+ * @category constants
+ */
+declare const PACKET_ID = "W5M0MpCehiHzreSzNTczkc9d";
+/**
+ * The padding a writable packet gets by default: 2 KiB, as the XMP
+ * specification recommends.
+ *
+ * @since 0.1.0
+ * @category constants
+ */
+declare const DEFAULT_PADDING = 2048;
+/**
+ * The text encoding of a packet.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Encoding = 'utf-8' | 'utf-16be' | 'utf-16le' | 'utf-32be' | 'utf-32le';
+/**
+ * A packet found in a byte sequence.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Packet {
+  /** The byte offset of `<?xpacket begin`. */
+  readonly offset: number;
+  /** The byte length, through the end of the `<?xpacket end …?>` trailer. */
+  readonly length: number;
+  readonly encoding: Encoding;
+  /** Whether the trailer is `end="w"` (the packet may be updated in place). */
+  readonly writable: boolean;
+  /** The decoded packet, header to trailer. */
+  readonly text: string;
+}
+/**
+ * The parts of a packet's text.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Unwrapped {
+  /** The serialized XMP between the header and the padding. */
+  readonly xml: string;
+  /** The number of whitespace characters of padding before the trailer. */
+  readonly padding: number;
+  readonly writable: boolean;
+}
+/**
+ * Finds the first packet at or after `fromIndex` in a byte sequence: a file
+ * of any format, scanned without parsing it (ISO 16684-1 §7.3.2's packet
+ * scanning).
+ *
+ * @since 0.1.0
+ * @category scanning
+ */
+declare const find: (bytes: Uint8Array, fromIndex?: number) => Option.Option<Packet>;
+/**
+ * Finds every packet in a byte sequence, in order.
+ *
+ * @since 0.1.0
+ * @category scanning
+ */
+declare const findAll: (bytes: Uint8Array) => ReadonlyArray<Packet>;
+/**
+ * Splits a packet's text into the serialized XMP, the padding and the
+ * writability of its trailer. Returns `None` when the text is not a packet.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const unwrap: (text: string) => Option.Option<Unwrapped>;
+/**
+ * Options for wrapping serialized XMP in a packet.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface WrapOptions {
+  /**
+   * Bytes of whitespace padding before the trailer. Defaults to
+   * `DEFAULT_PADDING` for a writable packet and 0 for a read-only one.
+   */
+  readonly padding?: number | undefined;
+  /** Whether the trailer is `end="w"` rather than `end="r"`. Defaults to `true`. */
+  readonly writable?: boolean | undefined;
+}
+/**
+ * Whitespace padding of exactly `bytes` bytes: lines of 99 spaces and a
+ * newline, as XMP writers lay it out.
+ *
+ * @since 0.1.0
+ * @category serializing
+ */
+declare const padding: (bytes: number) => string;
+/**
+ * Wraps serialized XMP (an `<x:xmpmeta>` element) in a UTF-8 packet.
+ *
+ * @since 0.1.0
+ * @category serializing
+ */
+declare const wrap: (xml: string, options?: WrapOptions) => string;
+/**
+ * The UTF-8 byte length of a string.
+ *
+ * @since 0.1.0
+ * @category serializing
+ */
+declare const byteLength: (text: string) => number;
+/**
+ * Wraps serialized XMP in a UTF-8 packet of exactly `size` bytes, padding the
+ * difference: how an XMP packet is updated in place in a file. Returns
+ * `None` when the XMP does not fit.
+ *
+ * @since 0.1.0
+ * @category serializing
+ */
+declare const wrapToSize: (xml: string, size: number, options?: {
+  readonly writable?: boolean | undefined;
+}) => Option.Option<string>;
+export { Packet_d_exports as a, byteLength as c, padding as d, unwrap as f, Packet as i, find as l, wrapToSize as m, Encoding as n, Unwrapped as o, wrap as p, PACKET_ID as r, WrapOptions as s, DEFAULT_PADDING as t, findAll as u };
+//# sourceMappingURL=Packet-Cy5g6XuW.d.mts.map

package/dist/Parser-p1Gyr0QN.d.mts

@@ -0,0 +1,85 @@
+import { nt as Update, q as Query } from "./Ast-vcw2W-lf.mjs";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+declare namespace Parser_d_exports {
+  export { ParseOptions, SparqlParseError, parse, parseQuery, parseQueryResult, parseQueryUnsafe, parseUpdate, parseUpdateResult, parseUpdateUnsafe };
+}
+declare const SparqlParseError_base: Schema.Class<SparqlParseError, Schema.TaggedStruct<"SparqlParseError", {
+  readonly message: Schema.String;
+  /** 1-based line of the error. */
+  readonly line: Schema.Number;
+  /** 1-based column of the error. */
+  readonly column: Schema.Number;
+  /** 0-based character offset of the error. */
+  readonly offset: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A syntax (or static semantic) error in a SPARQL query or update.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+declare class SparqlParseError extends SparqlParseError_base {}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface ParseOptions {
+  /** The base IRI used to resolve relative IRIs (unless overridden by `BASE`). */
+  readonly baseIri?: string | undefined;
+  /** Prefixes available without declaration. */
+  readonly prefixes?: Readonly<Record<string, string>> | undefined;
+}
+/**
+ * Parses a SPARQL query, returning a `Result`.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parseQueryResult: (input: string, options?: ParseOptions) => Result.Result<Query, SparqlParseError>;
+/**
+ * Parses a SPARQL update request, returning a `Result`.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parseUpdateResult: (input: string, options?: ParseOptions) => Result.Result<Update, SparqlParseError>;
+/**
+ * Parses a SPARQL query.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parseQuery: (input: string, options?: ParseOptions) => Effect.Effect<Query, SparqlParseError>;
+/**
+ * Parses a SPARQL update request.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parseUpdate: (input: string, options?: ParseOptions) => Effect.Effect<Update, SparqlParseError>;
+/**
+ * Parses either a query or an update request: the text is parsed as a query
+ * first and, if that fails, as an update.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parse: (input: string, options?: ParseOptions) => Effect.Effect<Query | Update, SparqlParseError>;
+/**
+ * Parses a SPARQL query, throwing a `SparqlParseError` on failure.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parseQueryUnsafe: (input: string, options?: ParseOptions) => Query;
+/**
+ * Parses a SPARQL update request, throwing a `SparqlParseError` on failure.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parseUpdateUnsafe: (input: string, options?: ParseOptions) => Update;
+export { parseQuery as a, parseUpdate as c, parse as i, parseUpdateResult as l, Parser_d_exports as n, parseQueryResult as o, SparqlParseError as r, parseQueryUnsafe as s, ParseOptions as t, parseUpdateUnsafe as u };
+//# sourceMappingURL=Parser-p1Gyr0QN.d.mts.map