@zanii/blackbox 0.21.2 → 0.23.0

package/dist/otlp/protobuf.js

@@ -165,3 +165,317 @@ export function otlpFromProtobuf(buf) {
         }),
     };
 }
+const KV = "KeyValue[]";
+const SCHEMAS = {
+    AnyValue: [
+        [1, "stringValue", "string"],
+        [2, "boolValue", "bool"],
+        [3, "intValue", "int64"],
+        [4, "doubleValue", "double"],
+        [5, "arrayValue", "ArrayValue"],
+        [6, "kvlistValue", "KeyValueList"],
+        [7, "bytesValue", "bytes"],
+    ],
+    ArrayValue: [[1, "values", "AnyValue[]"]],
+    KeyValueList: [[1, "values", KV]],
+    KeyValue: [
+        [1, "key", "string"],
+        [2, "value", "AnyValue"],
+    ],
+    Resource: [
+        [1, "attributes", KV],
+        [2, "droppedAttributesCount", "uint32"],
+    ],
+    Scope: [
+        [1, "name", "string"],
+        [2, "version", "string"],
+        [3, "attributes", KV],
+        [4, "droppedAttributesCount", "uint32"],
+    ],
+    traces: [[1, "resourceSpans", "ResourceSpans[]"]],
+    ResourceSpans: [
+        [1, "resource", "Resource"],
+        [2, "scopeSpans", "ScopeSpans[]"],
+        [3, "schemaUrl", "string"],
+    ],
+    ScopeSpans: [
+        [1, "scope", "Scope"],
+        [2, "spans", "Span[]"],
+        [3, "schemaUrl", "string"],
+    ],
+    Span: [
+        [1, "traceId", "id"],
+        [2, "spanId", "id"],
+        [3, "traceState", "string"],
+        [4, "parentSpanId", "id"],
+        [5, "name", "string"],
+        [6, "kind", "enum"],
+        [7, "startTimeUnixNano", "fixed64"],
+        [8, "endTimeUnixNano", "fixed64"],
+        [9, "attributes", KV],
+        [10, "droppedAttributesCount", "uint32"],
+        [11, "events", "SpanEvent[]"],
+        [12, "droppedEventsCount", "uint32"],
+        [13, "links", "Link[]"],
+        [14, "droppedLinksCount", "uint32"],
+        [15, "status", "Status"],
+        [16, "flags", "fixed32"],
+    ],
+    SpanEvent: [
+        [1, "timeUnixNano", "fixed64"],
+        [2, "name", "string"],
+        [3, "attributes", KV],
+        [4, "droppedAttributesCount", "uint32"],
+    ],
+    Link: [
+        [1, "traceId", "id"],
+        [2, "spanId", "id"],
+        [3, "traceState", "string"],
+        [4, "attributes", KV],
+        [5, "droppedAttributesCount", "uint32"],
+        [6, "flags", "fixed32"],
+    ],
+    Status: [
+        [2, "message", "string"],
+        [3, "code", "enum"],
+    ],
+    metrics: [[1, "resourceMetrics", "ResourceMetrics[]"]],
+    ResourceMetrics: [
+        [1, "resource", "Resource"],
+        [2, "scopeMetrics", "ScopeMetrics[]"],
+        [3, "schemaUrl", "string"],
+    ],
+    ScopeMetrics: [
+        [1, "scope", "Scope"],
+        [2, "metrics", "Metric[]"],
+        [3, "schemaUrl", "string"],
+    ],
+    Metric: [
+        [1, "name", "string"],
+        [2, "description", "string"],
+        [3, "unit", "string"],
+        [5, "gauge", "Gauge"],
+        [7, "sum", "Sum"],
+        [9, "histogram", "Histogram"],
+        [10, "exponentialHistogram", "ExponentialHistogram"],
+        [11, "summary", "Summary"],
+    ],
+    Gauge: [[1, "dataPoints", "NumberDataPoint[]"]],
+    Sum: [
+        [1, "dataPoints", "NumberDataPoint[]"],
+        [2, "aggregationTemporality", "enum"],
+        [3, "isMonotonic", "bool"],
+    ],
+    Histogram: [
+        [1, "dataPoints", "HistogramDataPoint[]"],
+        [2, "aggregationTemporality", "enum"],
+    ],
+    ExponentialHistogram: [
+        [1, "dataPoints", "ExponentialHistogramDataPoint[]"],
+        [2, "aggregationTemporality", "enum"],
+    ],
+    Summary: [[1, "dataPoints", "SummaryDataPoint[]"]],
+    NumberDataPoint: [
+        [2, "startTimeUnixNano", "fixed64"],
+        [3, "timeUnixNano", "fixed64"],
+        [4, "asDouble", "double"],
+        [6, "asInt", "sfixed64"],
+        [7, "attributes", KV],
+        [8, "flags", "uint32"],
+    ],
+    HistogramDataPoint: [
+        [2, "startTimeUnixNano", "fixed64"],
+        [3, "timeUnixNano", "fixed64"],
+        [4, "count", "fixed64"],
+        [5, "sum", "double"],
+        [6, "bucketCounts", "fixed64[]"],
+        [7, "explicitBounds", "double[]"],
+        [9, "attributes", KV],
+        [10, "flags", "uint32"],
+        [11, "min", "double"],
+        [12, "max", "double"],
+    ],
+    // ponytail: an exponential histogram's buckets and a summary's quantiles aren't read
+    ExponentialHistogramDataPoint: [
+        [1, "attributes", KV],
+        [2, "startTimeUnixNano", "fixed64"],
+        [3, "timeUnixNano", "fixed64"],
+        [4, "count", "fixed64"],
+        [5, "sum", "double"],
+        [6, "scale", "sint32"],
+        [7, "zeroCount", "fixed64"],
+        [10, "flags", "uint32"],
+        [12, "min", "double"],
+        [13, "max", "double"],
+    ],
+    SummaryDataPoint: [
+        [2, "startTimeUnixNano", "fixed64"],
+        [3, "timeUnixNano", "fixed64"],
+        [4, "count", "fixed64"],
+        [5, "sum", "double"],
+        [7, "attributes", KV],
+        [8, "flags", "uint32"],
+    ],
+    logs: [[1, "resourceLogs", "ResourceLogs[]"]],
+    ResourceLogs: [
+        [1, "resource", "Resource"],
+        [2, "scopeLogs", "ScopeLogs[]"],
+        [3, "schemaUrl", "string"],
+    ],
+    ScopeLogs: [
+        [1, "scope", "Scope"],
+        [2, "logRecords", "LogRecord[]"],
+        [3, "schemaUrl", "string"],
+    ],
+    LogRecord: [
+        [1, "timeUnixNano", "fixed64"],
+        [2, "severityNumber", "enum"],
+        [3, "severityText", "string"],
+        [5, "body", "AnyValue"],
+        [6, "attributes", KV],
+        [7, "droppedAttributesCount", "uint32"],
+        [8, "flags", "fixed32"],
+        [9, "traceId", "id"],
+        [10, "spanId", "id"],
+        [11, "observedTimeUnixNano", "fixed64"],
+        [12, "eventName", "string"],
+    ],
+};
+const VARINT = new Set(["bool", "enum", "uint32", "int64", "sint32"]);
+const FIXED64 = new Set(["fixed64", "sfixed64", "double"]);
+const wireOf = (t) => (VARINT.has(t) ? 0 : FIXED64.has(t) ? 1 : t === "fixed32" ? 5 : 2);
+function scalarOf(t, v) {
+    if (v instanceof Uint8Array)
+        return t === "id" ? hex(v) : t === "bytes" ? Buffer.from(v).toString("base64") : text(v);
+    if (t === "bool")
+        return v !== 0n;
+    if (t === "double")
+        return float64(v);
+    if (t === "int64" || t === "sfixed64")
+        return BigInt.asIntN(64, v).toString();
+    if (t === "fixed64")
+        return v.toString();
+    if (t === "sint32")
+        return Number((v >> 1n) ^ -(v & 1n));
+    return Number(v); // enum, uint32, fixed32
+}
+function decode(b, name) {
+    const schema = SCHEMAS[name];
+    const out = {};
+    for (const f of fields(b)) {
+        const spec = schema.find((s) => s[0] === f.n);
+        if (!spec)
+            continue;
+        const [, key, type] = spec;
+        const repeated = type.endsWith("[]");
+        const t = repeated ? type.slice(0, -2) : type;
+        let values;
+        if (SCHEMAS[t]) {
+            if (f.wire !== 2)
+                throw new Error(`protobuf: ${name}.${key} isn't a message`);
+            values = [decode(bytes(f), t)];
+        }
+        else if (repeated && f.wire === 2 && wireOf(t) !== 2) {
+            // a packed run of fixed64s or doubles
+            const raw = bytes(f);
+            if (raw.length % 8)
+                throw new Error(`protobuf: ${name}.${key} isn't packed 64-bit values`);
+            values = [];
+            for (let k = 0; k < raw.length; k += 8) {
+                let v = 0n;
+                for (let j = 7; j >= 0; j--)
+                    v = (v << 8n) | BigInt(raw[k + j]);
+                values.push(scalarOf(t, v));
+            }
+        }
+        else {
+            if (f.wire !== wireOf(t))
+                throw new Error(`protobuf: ${name}.${key} has the wrong wire type`);
+            values = [scalarOf(t, f.v)];
+        }
+        if (repeated)
+            out[key] = [...(out[key] ?? []), ...values];
+        else
+            out[key] = values[0];
+    }
+    return out;
+}
+/** spec/otlp.md §6: an Export{Trace,Metrics,Logs}ServiceRequest's bytes as OTLP/JSON, every field
+ * read (64-bit integers as strings, ids as hex). Throws on bad bytes. */
+export function otlpDecode(buf, signal) {
+    return decode(buf, signal);
+}
+const varintBytes = (n) => {
+    const out = [];
+    let v = BigInt.asUintN(64, n);
+    while (v > 0x7fn) {
+        out.push(Number(v & 0x7fn) | 0x80);
+        v >>= 7n;
+    }
+    out.push(Number(v));
+    return out;
+};
+const fixedBytes = (v, size) => {
+    const out = [];
+    let x = BigInt.asUintN(size * 8, v);
+    for (let k = 0; k < size; k++) {
+        out.push(Number(x & 0xffn));
+        x >>= 8n;
+    }
+    return out;
+};
+const doubleBits = (x) => {
+    const view = new DataView(new ArrayBuffer(8));
+    view.setFloat64(0, x, true);
+    return view.getBigUint64(0, true);
+};
+const integer = (v) => BigInt(typeof v === "number" ? Math.trunc(v) : String(v));
+function scalarBytes(t, v) {
+    if (t === "string")
+        return [...new TextEncoder().encode(String(v))];
+    if (t === "id")
+        return [...Buffer.from(String(v), "hex")];
+    if (t === "bytes")
+        return [...Buffer.from(String(v), "base64")];
+    if (t === "bool")
+        return varintBytes(v ? 1n : 0n);
+    if (t === "sint32") {
+        const n = integer(v);
+        return varintBytes(n < 0n ? -2n * n - 1n : 2n * n);
+    }
+    if (VARINT.has(t))
+        return varintBytes(integer(v));
+    if (t === "double")
+        return fixedBytes(doubleBits(Number(v)), 8);
+    if (t === "fixed32")
+        return fixedBytes(integer(v), 4);
+    return fixedBytes(integer(v), 8); // fixed64, sfixed64
+}
+function encode(o, name) {
+    const out = [];
+    for (const [n, key, type] of SCHEMAS[name]) {
+        const v = o[key];
+        if (v === undefined || v === null)
+            continue;
+        const repeated = type.endsWith("[]");
+        const t = repeated ? type.slice(0, -2) : type;
+        const wire = SCHEMAS[t] ? 2 : wireOf(t);
+        const tag = varintBytes(BigInt((n << 3) | (repeated ? 2 : wire)));
+        if (repeated && wire !== 2) {
+            // packed: one length-delimited run
+            const run = v.flatMap((x) => scalarBytes(t, x));
+            out.push(...tag, ...varintBytes(BigInt(run.length)), ...run);
+            continue;
+        }
+        for (const x of repeated ? v : [v]) {
+            const body = SCHEMAS[t] ? encode(x, t) : scalarBytes(t, x);
+            out.push(...tag, ...(wire === 2 ? varintBytes(BigInt(body.length)) : []), ...body);
+        }
+    }
+    return out;
+}
+/** spec/otlp.md §6: OTLP/JSON as the Export{Trace,Metrics,Logs}ServiceRequest's protobuf bytes,
+ * the fields in number order, so both SDKs give the same bytes (spec/vectors/otlp-protobuf-out.json). */
+export function otlpEncode(doc, signal) {
+    return Uint8Array.from(encode(doc, signal));
+}

package/dist/packs/index.d.ts

@@ -20,6 +20,7 @@ export declare function packData(packs: readonly unknown[]): DataRules;
 /** spec/packs.md §2: the core pack, from the built-in frameworks files. */
 export declare function corePack(compliance: {
     notes: string;
+    notes_ar?: string;
     frameworks: Obj;
 }, occurrence: {
     notes: string;
@@ -32,6 +33,7 @@ export declare function corePack(compliance: {
     status: string;
     compliance: {
         notes: string;
+        notes_ar?: string;
         frameworks: Obj;
     };
     occurrence: {

package/dist/packs/index.js

@@ -337,7 +337,11 @@ export function corePack(compliance, occurrence) {
         id: "core",
         title: "Core (built in)",
         status: "draft",
-        compliance: { notes: compliance.notes, frameworks: compliance.frameworks },
+        compliance: {
+            notes: compliance.notes,
+            ...(compliance.notes_ar ? { notes_ar: compliance.notes_ar } : {}),
+            frameworks: compliance.frameworks,
+        },
         occurrence: {
             notes: occurrence.notes,
             ...(occurrence.notes_ar ? { notes_ar: occurrence.notes_ar } : {}),

package/dist/pdf/arabic.d.ts

@@ -0,0 +1,45 @@
+/** spec/pdf/unicode-arabic.json */
+export interface UnicodeTables {
+    unicode: string;
+    bidi: Array<[number, string]>;
+    joining: Array<[number, number, string]>;
+    forms: number[][];
+    lam_alef: number[][];
+    mirror: number[][];
+    brackets: Array<[number, number, string]>;
+}
+/** The tables as lookups (built once per document). */
+export interface Prepared {
+    cls: (cp: number) => string;
+    jt: (cp: number) => string;
+    forms: Map<number, number[]>;
+    lamAlef: Map<number, number[]>;
+    mirror: Map<number, number>;
+    brackets: Map<number, [number, string]>;
+}
+/** One base character (or a ligature) with the marks on it, in logical order. */
+export interface Cluster {
+    /** The code points to draw: the shaped base, then its marks. Empty for a control. */
+    cps: number[];
+    /** The logical text it stands for ("" for a control). */
+    src: string;
+    /** The Bidi_Class of its first character. */
+    cls: string;
+}
+export declare function prepare(u: UnicodeTables): Prepared;
+/** §6.1: the text as clusters, letters in their joining forms, lam-alef as one ligature. */
+export declare function shapeClusters(text: string, P: Prepared): Cluster[];
+/** §6.1: the shaped text (presentation forms, logical order). */
+export declare function shapeArabic(text: string, tables: UnicodeTables): string;
+/** §6.2: the embedding level of each cluster in a paragraph of level `p` (0 or 1). */
+export declare function bidiLevels(clusters: Cluster[], p: number, P: Prepared): number[];
+/** L1-L2 and L4 for one line (`line`: cluster indices in logical order): the indices in visual
+ * order, controls left out, each cluster's code points with mirroring applied, and whether its
+ * level is odd (right to left). */
+export declare function reorderLine(line: number[], clusters: Cluster[], levels: number[], p: number, P: Prepared): Array<{
+    index: number;
+    cps: number[];
+    odd: boolean;
+}>;
+/** §6.2: one line of text, shaped and in visual (left to right) order, in a paragraph of level `p`. */
+export declare function visualLine(text: string, p: number, tables: UnicodeTables): string;