web-doc 0.6.2 → 0.7.0

package/dist/edit/pptx/text.js

@@ -0,0 +1,99 @@
+/*
+ * The text model of a text body: paragraphs joined by "\n", line breaks
+ * (a:br) as "\v" — the character PowerPoint itself uses — and fields as
+ * their cached text. Offsets are UTF-16 code units of the joined text.
+ */
+export const PARAGRAPH_BREAK = "\n";
+export const LINE_BREAK = "\u000b";
+/** Reads the text of a `p:txBody` or `a:txBody`. */
+export function readTextModel(part, txBody) {
+    const paragraphs = [];
+    let text = "";
+    const paragraphNodes = txBody.children.filter((child) => child.local === "p");
+    paragraphNodes.forEach((paragraph, index) => {
+        if (index > 0)
+            text += PARAGRAPH_BREAK;
+        const start = text.length;
+        const runs = [];
+        let pPr;
+        let endParaRPr;
+        for (const child of paragraph.children) {
+            switch (child.local) {
+                case "pPr":
+                    pPr = child;
+                    break;
+                case "endParaRPr":
+                    endParaRPr = child;
+                    break;
+                case "r":
+                case "fld": {
+                    const t = child.children.find((node) => node.local === "t");
+                    const value = t ? part.textOf(t) : "";
+                    const rPr = child.children.find((node) => node.local === "rPr");
+                    runs.push({
+                        node: child,
+                        kind: child.local,
+                        start: text.length,
+                        end: text.length + value.length,
+                        text: value,
+                        ...(rPr ? { rPr } : {}),
+                    });
+                    text += value;
+                    break;
+                }
+                case "br": {
+                    const rPr = child.children.find((node) => node.local === "rPr");
+                    runs.push({
+                        node: child,
+                        kind: "br",
+                        start: text.length,
+                        end: text.length + 1,
+                        text: LINE_BREAK,
+                        ...(rPr ? { rPr } : {}),
+                    });
+                    text += LINE_BREAK;
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+        const level = pPr ? Number(part.attribute(pPr, "lvl") ?? "0") || 0 : 0;
+        paragraphs.push({
+            node: paragraph,
+            start,
+            end: text.length,
+            runs,
+            ...(pPr ? { pPr } : {}),
+            level,
+            ...(endParaRPr ? { endParaRPr } : {}),
+        });
+    });
+    return { text, paragraphs };
+}
+/** The first run that draws text, with its paragraph; undefined for an empty body. */
+export function firstTextRun(model) {
+    for (const paragraph of model.paragraphs)
+        for (const run of paragraph.runs)
+            if (run.kind !== "br" && run.text.length > 0)
+                return { run, paragraph };
+    return undefined;
+}
+/** The cells of an `a:tbl`, row by row, as text models. */
+export function readTableCells(part, tbl) {
+    const rows = [];
+    for (const tr of tbl.children.filter((child) => child.local === "tr")) {
+        const cells = [];
+        for (const tc of tr.children.filter((child) => child.local === "tc")) {
+            const txBody = tc.children.find((child) => child.local === "txBody");
+            cells.push({
+                node: tc,
+                model: txBody
+                    ? readTextModel(part, txBody)
+                    : { text: "", paragraphs: [] },
+            });
+        }
+        rows.push(cells);
+    }
+    return rows;
+}

package/dist/edit/pptx/types.d.ts

@@ -0,0 +1,232 @@
+import type { ApplyOptions, BinaryData, EditColor, EditElement, EditReceipt, EditSessionBase, PagePoint, PageRect, ReadOptions, ReadResult, SavedDocument, SaveOptions, TextRange } from "../types.js";
+export type PptxElementKind = "shape" | "image" | "table" | "connector" | "group" | "other";
+export type PptxTextAlign = "left" | "center" | "right" | "justify";
+/** The style of the first run with text, resolved through the placeholder chain and the theme. */
+export interface PptxTextStyle {
+    /** Theme fonts resolved: "+mn-lt" becomes the minor Latin face. */
+    readonly fontFamily: string;
+    /** Points. */
+    readonly fontSize: number;
+    readonly bold: boolean;
+    readonly italic: boolean;
+    readonly underline: boolean;
+    /** `#RRGGBB`, `{ theme, mods }` when the file uses a scheme colour, "auto" when unresolvable. */
+    readonly color: EditColor;
+    readonly align: PptxTextAlign;
+}
+export interface PptxLineStyle {
+    readonly color: EditColor | "none";
+    /** Points. */
+    readonly width: number;
+}
+export interface PptxShapeStyle {
+    /** "none" for a:noFill; absent when inherited from the shape style or the theme. */
+    readonly fill?: EditColor | "none";
+    readonly line?: PptxLineStyle;
+}
+export interface PptxPlaceholder {
+    /** `p:ph/@type`, "body" when the file leaves it out. */
+    readonly type: string;
+    readonly idx?: number;
+}
+export interface PptxElement extends EditElement {
+    readonly kind: PptxElementKind;
+    /** `p:cNvPr/@name`, as PowerPoint shows it in the selection pane. */
+    readonly name: string;
+    readonly placeholder?: PptxPlaceholder;
+    /** Present for a shape with a text body. */
+    readonly textStyle?: PptxTextStyle;
+    /** Present for shapes and connectors. */
+    readonly shapeStyle?: PptxShapeStyle;
+    /** Present for a table. */
+    readonly table?: {
+        readonly rows: readonly (readonly string[])[];
+    };
+    /** `p:cNvPr/@hidden`: listed and editable, but not drawn by the renderer. */
+    readonly hidden?: boolean;
+}
+export interface PptxSlideInfo {
+    readonly pageIndex: number;
+    /** Stable for the session: the slide part's number, as in element ids ("sld3"). */
+    readonly key: string;
+    /** A `PptxLayoutInfo` id. */
+    readonly layout: string;
+    readonly hidden: boolean;
+}
+export interface PptxLayoutInfo {
+    /** "layout2": from the layout part's number. */
+    readonly id: string;
+    /** `p:cSld/@name`, for example "Title and Content". */
+    readonly name: string;
+    /** `p:sldLayout/@type` when present. */
+    readonly type?: string;
+    /** "master1": from the master part's number. */
+    readonly master: string;
+}
+export interface PptxTextStyleChange {
+    /** Written as a:latin/@typeface; theme names ("+mn-lt") pass through. */
+    readonly fontFamily?: string;
+    /** 1–400 points. */
+    readonly fontSize?: number;
+    readonly bold?: boolean;
+    readonly italic?: boolean;
+    readonly underline?: boolean;
+    /** `#RRGGBB` writes a:srgbClr; `{ theme, mods }` writes a:schemeClr with modifiers. */
+    readonly color?: EditColor;
+    /** a:pPr/@algn on every paragraph the range touches. */
+    readonly align?: PptxTextAlign;
+}
+export interface PptxTableStyle {
+    /** Header-row flag of the table; default true. */
+    readonly firstRow?: boolean;
+    /** Banded-rows flag of the table; default true. */
+    readonly bandRow?: boolean;
+}
+export interface PptxLineChange {
+    readonly color: EditColor | "none";
+    /** Points; kept when absent. */
+    readonly width?: number;
+}
+export interface PptxReplaceTextOperation {
+    readonly op: "replaceText";
+    /** A `shape` element with a text body. */
+    readonly target: string;
+    readonly text: string;
+    /** Both ends on the target; absent, the whole text; collapsed, an insertion. */
+    readonly range?: TextRange;
+}
+export interface PptxSetTextStyleOperation {
+    readonly op: "setTextStyle";
+    readonly target: string;
+    readonly range?: TextRange;
+    readonly style: PptxTextStyleChange;
+}
+export interface PptxSetShapeStyleOperation {
+    readonly op: "setShapeStyle";
+    /** A `shape` or `connector` element. */
+    readonly target: string;
+    /** A colour, "none" for no fill, `null` to drop the explicit fill, absent to keep it. */
+    readonly fill?: EditColor | "none" | null;
+    /** A line, "none" for no line, `null` to drop the explicit line, absent to keep it. */
+    readonly line?: PptxLineChange | "none" | null;
+}
+export interface PptxMoveElementOperation {
+    readonly op: "moveElement";
+    readonly target: string;
+    /** New top-left corner of the element's bounds, in slide space. */
+    readonly to?: PagePoint;
+    /** Offset in slide space. Exactly one of `to` and `by` is given. */
+    readonly by?: {
+        readonly dx: number;
+        readonly dy: number;
+    };
+}
+export interface PptxResizeElementOperation {
+    readonly op: "resizeElement";
+    readonly target: string;
+    /** New bounds in slide space; the rotation is kept. */
+    readonly rect: PageRect;
+}
+export interface PptxDeleteElementOperation {
+    readonly op: "deleteElement";
+    readonly target: string;
+}
+export interface PptxInsertTextBoxOperation {
+    readonly op: "insertTextBox";
+    readonly pageIndex: number;
+    readonly rect: PageRect;
+    readonly text: string;
+    readonly style?: PptxTextStyleChange;
+}
+export interface PptxInsertImageOperation {
+    readonly op: "insertImage";
+    readonly pageIndex: number;
+    readonly rect: PageRect;
+    /** PNG or JPEG bytes; base64 over pure-JSON transports. */
+    readonly data: BinaryData;
+    readonly mimeType: "image/png" | "image/jpeg";
+}
+export interface PptxInsertTableOperation {
+    readonly op: "insertTable";
+    readonly pageIndex: number;
+    readonly rect: PageRect;
+    /** Cell text by row; every row has the same number of cells. 1–100 rows, 1–20 columns. */
+    readonly rows: readonly (readonly string[])[];
+    /** Relative column weights, one per column; equal when omitted. */
+    readonly columnWidths?: readonly number[];
+    readonly style?: PptxTableStyle;
+}
+export interface PptxSetTableCellOperation {
+    readonly op: "setTableCell";
+    /** A `table` element. */
+    readonly target: string;
+    readonly row: number;
+    readonly column: number;
+    /** The cell's new text; empty clears the cell. */
+    readonly text: string;
+}
+export interface PptxInsertSlideOperation {
+    readonly op: "insertSlide";
+    /** Position of the new slide, 0 to the current slide count. */
+    readonly index: number;
+    /** A layout id; default: the layout of the slide before the position, else the first layout. */
+    readonly layout?: string;
+}
+export interface PptxDuplicateSlideOperation {
+    readonly op: "duplicateSlide";
+    readonly pageIndex: number;
+    /** Position of the copy; default: right after the source. */
+    readonly index?: number;
+}
+export interface PptxDeleteSlideOperation {
+    readonly op: "deleteSlide";
+    readonly pageIndex: number;
+}
+export interface PptxMoveSlideOperation {
+    readonly op: "moveSlide";
+    readonly from: number;
+    /** The slide's index after the move. */
+    readonly to: number;
+}
+/** The PPTX operation union; operations are added as they ship. */
+export type PptxOperation = PptxReplaceTextOperation | PptxSetTextStyleOperation | PptxSetShapeStyleOperation | PptxMoveElementOperation | PptxResizeElementOperation | PptxDeleteElementOperation | PptxInsertTextBoxOperation | PptxInsertImageOperation | PptxInsertTableOperation | PptxSetTableCellOperation | PptxInsertSlideOperation | PptxDuplicateSlideOperation | PptxDeleteSlideOperation | PptxMoveSlideOperation;
+/** PPTX saves have no fields of their own yet. */
+export type PptxSaveOptions = SaveOptions;
+/** An operation's fields without its `op`, as the typed methods take them. */
+export type PptxFields<T extends PptxOperation> = T extends unknown ? Omit<T, "op"> : never;
+export interface PptxEditSession extends EditSessionBase<PptxOperation, PptxElement> {
+    readonly format: "pptx";
+    save(options?: PptxSaveOptions): Promise<SavedDocument>;
+    /** The slides in presentation order, with keys that survive reordering. */
+    getSlides(options?: ReadOptions): Promise<ReadResult<PptxSlideInfo>>;
+    /** Every layout of every master, for `insertSlide`. */
+    getLayouts(options?: ReadOptions): Promise<ReadResult<PptxLayoutInfo>>;
+    /** Replaces the whole text of a shape, or the part a range covers. */
+    replaceText(fields: PptxFields<PptxReplaceTextOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Changes run and paragraph properties; unspecified ones keep their bytes. */
+    setTextStyle(fields: PptxFields<PptxSetTextStyleOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Changes or removes a shape's fill and line. */
+    setShapeStyle(fields: PptxFields<PptxSetShapeStyleOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Moves an element to a point or by an offset, in slide space. */
+    moveElement(fields: PptxFields<PptxMoveElementOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Gives an element new bounds; its rotation is kept. */
+    resizeElement(fields: PptxFields<PptxResizeElementOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Removes an element and, for a group, every element in it. */
+    deleteElement(fields: PptxFields<PptxDeleteElementOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Adds a text box; its id is in `createdIds`. */
+    insertTextBox(fields: PptxFields<PptxInsertTextBoxOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Places a PNG or JPEG inside `rect` as a picture. */
+    insertImage(fields: PptxFields<PptxInsertImageOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Adds a table with the given cell text. */
+    insertTable(fields: PptxFields<PptxInsertTableOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Changes one cell's text. */
+    setTableCell(fields: PptxFields<PptxSetTableCellOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Adds a slide from a layout. */
+    insertSlide(fields: PptxFields<PptxInsertSlideOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Copies a slide. */
+    duplicateSlide(fields: PptxFields<PptxDuplicateSlideOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Removes a slide; the last slide cannot be removed. */
+    deleteSlide(fields: PptxFields<PptxDeleteSlideOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Reorders slides. */
+    moveSlide(fields: PptxFields<PptxMoveSlideOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+}

package/dist/edit/pptx/types.js

@@ -0,0 +1 @@
+export {};

package/dist/edit/schema.d.ts

@@ -0,0 +1,11 @@
+import type { JsonSchema, OperationIssue } from "./types.js";
+/** Collects every issue of `value` against `schema`; an empty result means valid. */
+export declare function validateSchema(value: unknown, schema: JsonSchema, operationIndex: number): OperationIssue[];
+/**
+ * Throws when a schema uses a keyword the validator does not implement, so a
+ * constraint can never be silently ignored. Run by the tests over every
+ * operation schema.
+ */
+export declare function assertSupportedSchema(schema: JsonSchema, path?: string): void;
+/** JSON Pointer segment escaping (RFC 6901). */
+export declare function pointerSegment(segment: string | number): string;

package/dist/edit/schema.js

@@ -0,0 +1,275 @@
+/*
+ * A validator for the subset of JSON Schema 2020-12 that operation schemas
+ * use. The same schemas are exported to clients, so they must stay valid JSON
+ * Schema; the only extension is `x-binary`, which marks a value that may be a
+ * `Uint8Array` in-process or a base64 string in JSON.
+ */
+const SUPPORTED_KEYWORDS = new Set([
+    "$schema",
+    "$id",
+    "$defs",
+    "$ref",
+    "title",
+    "description",
+    "default",
+    "examples",
+    "type",
+    "properties",
+    "required",
+    "additionalProperties",
+    "enum",
+    "const",
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "minLength",
+    "maxLength",
+    "pattern",
+    "items",
+    "minItems",
+    "maxItems",
+    "oneOf",
+    "contentEncoding",
+    "x-binary",
+]);
+const BASE64 = /^[A-Za-z0-9+/]*={0,2}$/;
+/** A content-addressed reference to data registered with `addAsset()`. */
+const ASSET_REFERENCE = /^asset:[0-9a-f]{64}$/;
+/** Collects every issue of `value` against `schema`; an empty result means valid. */
+export function validateSchema(value, schema, operationIndex) {
+    const issues = [];
+    visit(value, schema, schema, "", operationIndex, issues);
+    return issues;
+}
+/**
+ * Throws when a schema uses a keyword the validator does not implement, so a
+ * constraint can never be silently ignored. Run by the tests over every
+ * operation schema.
+ */
+export function assertSupportedSchema(schema, path = "#") {
+    for (const [keyword, child] of Object.entries(schema)) {
+        if (!SUPPORTED_KEYWORDS.has(keyword))
+            throw new Error(`Unsupported JSON Schema keyword ${keyword} at ${path}`);
+        if (keyword === "properties" || keyword === "$defs")
+            for (const [name, nested] of Object.entries(asRecord(child)))
+                assertSupportedSchema(asRecord(nested), `${path}/${keyword}/${name}`);
+        else if (keyword === "items" || keyword === "additionalProperties") {
+            if (isRecord(child))
+                assertSupportedSchema(child, `${path}/${keyword}`);
+        }
+        else if (keyword === "oneOf")
+            asArray(child).forEach((nested, index) => assertSupportedSchema(asRecord(nested), `${path}/oneOf/${index}`));
+    }
+}
+/** JSON Pointer segment escaping (RFC 6901). */
+export function pointerSegment(segment) {
+    return `/${String(segment).replaceAll("~", "~0").replaceAll("/", "~1")}`;
+}
+function visit(value, schema, root, path, operationIndex, issues) {
+    const issue = (code, message) => {
+        issues.push({ operationIndex, path, code, message });
+    };
+    if (typeof schema.$ref === "string") {
+        visit(value, resolveRef(schema.$ref, root), root, path, operationIndex, issues);
+        return;
+    }
+    if (schema["x-binary"] === true) {
+        if (value instanceof Uint8Array)
+            return;
+        const base64 = typeof value === "string" && value.length % 4 === 0 && BASE64.test(value);
+        if (typeof value !== "string" || (!base64 && !ASSET_REFERENCE.test(value)))
+            issue("binary", "Expected bytes, a base64 string or an asset reference");
+        return;
+    }
+    if (Array.isArray(schema.oneOf)) {
+        visitOneOf(value, schema.oneOf, root, path, operationIndex, issues);
+        return;
+    }
+    if (schema.const !== undefined && !sameJson(value, schema.const)) {
+        issue("const", `Expected ${JSON.stringify(schema.const)}`);
+        return;
+    }
+    if (Array.isArray(schema.enum) &&
+        !schema.enum.some((candidate) => sameJson(value, candidate))) {
+        issue("enum", `Expected one of ${schema.enum.map((candidate) => JSON.stringify(candidate)).join(", ")}`);
+        return;
+    }
+    const types = schemaTypes(schema.type);
+    if (types && !types.some((type) => hasType(value, type))) {
+        issue("type", `Expected ${types.join(" or ")}`);
+        return;
+    }
+    if (typeof value === "number")
+        checkNumber(value, schema, issue);
+    else if (typeof value === "string")
+        checkString(value, schema, issue);
+    else if (Array.isArray(value))
+        checkArray(value, schema, root, path, operationIndex, issues, issue);
+    else if (isRecord(value))
+        checkObject(value, schema, root, path, operationIndex, issues);
+}
+function visitOneOf(value, branches, root, path, operationIndex, issues) {
+    const results = branches.map((branch) => collect(value, branch, root, path, operationIndex));
+    const matching = results.filter((result) => result.length === 0).length;
+    if (matching === 1)
+        return;
+    if (matching > 1) {
+        issues.push({
+            operationIndex,
+            path,
+            code: "one-of",
+            message: "Matches more than one allowed shape",
+        });
+        return;
+    }
+    // A branch whose discriminating constants all match explains the failure
+    // better than a generic message, for example a known `op` with a bad field.
+    const discriminated = branches.findIndex((branch) => discriminatorMatches(value, branch, root));
+    if (discriminated >= 0) {
+        issues.push(...results[discriminated]);
+        return;
+    }
+    issues.push({
+        operationIndex,
+        path,
+        code: "one-of",
+        message: "Does not match any allowed shape",
+    });
+}
+function collect(value, schema, root, path, operationIndex) {
+    const issues = [];
+    visit(value, schema, root, path, operationIndex, issues);
+    return issues;
+}
+function discriminatorMatches(value, branch, root) {
+    const schema = typeof branch.$ref === "string" ? resolveRef(branch.$ref, root) : branch;
+    if (!isRecord(value) || !isRecord(schema.properties))
+        return false;
+    const constants = Object.entries(schema.properties).filter(([, property]) => isRecord(property) && property.const !== undefined);
+    return (constants.length > 0 &&
+        constants.every(([name, property]) => sameJson(value[name], property.const)));
+}
+function checkNumber(value, schema, issue) {
+    if (typeof schema.minimum === "number" && value < schema.minimum)
+        issue("minimum", `Must be at least ${schema.minimum}`);
+    if (typeof schema.maximum === "number" && value > schema.maximum)
+        issue("maximum", `Must be at most ${schema.maximum}`);
+    if (typeof schema.exclusiveMinimum === "number" &&
+        value <= schema.exclusiveMinimum)
+        issue("minimum", `Must be greater than ${schema.exclusiveMinimum}`);
+    if (typeof schema.exclusiveMaximum === "number" &&
+        value >= schema.exclusiveMaximum)
+        issue("maximum", `Must be less than ${schema.exclusiveMaximum}`);
+}
+function checkString(value, schema, issue) {
+    // Lengths count code points, as JSON Schema specifies.
+    const length = [...value].length;
+    if (typeof schema.minLength === "number" && length < schema.minLength)
+        issue("min-length", `Must have at least ${schema.minLength} characters`);
+    if (typeof schema.maxLength === "number" && length > schema.maxLength)
+        issue("max-length", `Must have at most ${schema.maxLength} characters`);
+    if (typeof schema.pattern === "string" &&
+        !new RegExp(schema.pattern, "u").test(value))
+        issue("pattern", `Must match ${schema.pattern}`);
+}
+function checkArray(value, schema, root, path, operationIndex, issues, issue) {
+    if (typeof schema.minItems === "number" && value.length < schema.minItems)
+        issue("min-items", `Must have at least ${schema.minItems} items`);
+    if (typeof schema.maxItems === "number" && value.length > schema.maxItems)
+        issue("max-items", `Must have at most ${schema.maxItems} items`);
+    if (isRecord(schema.items))
+        value.forEach((item, index) => visit(item, schema.items, root, `${path}${pointerSegment(index)}`, operationIndex, issues));
+}
+function checkObject(value, schema, root, path, operationIndex, issues) {
+    const properties = isRecord(schema.properties) ? schema.properties : {};
+    // An explicit `undefined` counts as absent, as it does in JSON.
+    for (const name of asArray(schema.required))
+        if (typeof name === "string" && value[name] === undefined)
+            issues.push({
+                operationIndex,
+                path: `${path}${pointerSegment(name)}`,
+                code: "required",
+                message: "Required",
+            });
+    for (const [name, child] of Object.entries(value)) {
+        if (child === undefined)
+            continue;
+        const childPath = `${path}${pointerSegment(name)}`;
+        const property = properties[name];
+        if (isRecord(property)) {
+            visit(child, property, root, childPath, operationIndex, issues);
+        }
+        else if (schema.additionalProperties === false) {
+            issues.push({
+                operationIndex,
+                path: childPath,
+                code: "additional-property",
+                message: "Unknown property",
+            });
+        }
+        else if (isRecord(schema.additionalProperties)) {
+            visit(child, schema.additionalProperties, root, childPath, operationIndex, issues);
+        }
+    }
+}
+function resolveRef(reference, root) {
+    const prefix = "#/$defs/";
+    const definitions = isRecord(root.$defs) ? root.$defs : {};
+    const target = reference.startsWith(prefix)
+        ? definitions[reference.slice(prefix.length)]
+        : undefined;
+    if (!isRecord(target))
+        throw new Error(`Unresolvable JSON Schema reference ${reference}`);
+    return target;
+}
+function schemaTypes(type) {
+    if (typeof type === "string")
+        return [type];
+    if (Array.isArray(type))
+        return type;
+    return undefined;
+}
+function hasType(value, type) {
+    switch (type) {
+        case "object":
+            return isRecord(value);
+        case "array":
+            return Array.isArray(value);
+        case "string":
+            return typeof value === "string";
+        case "number":
+            return typeof value === "number" && Number.isFinite(value);
+        case "integer":
+            return Number.isInteger(value);
+        case "boolean":
+            return typeof value === "boolean";
+        case "null":
+            return value === null;
+    }
+}
+function sameJson(left, right) {
+    if (left === right)
+        return true;
+    if (Array.isArray(left) && Array.isArray(right))
+        return (left.length === right.length &&
+            left.every((item, index) => sameJson(item, right[index])));
+    if (isRecord(left) && isRecord(right)) {
+        const leftKeys = Object.keys(left);
+        return (leftKeys.length === Object.keys(right).length &&
+            leftKeys.every((key) => sameJson(left[key], right[key])));
+    }
+    return false;
+}
+function isRecord(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        !(value instanceof Uint8Array));
+}
+function asRecord(value) {
+    return isRecord(value) ? value : {};
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}